Updated package versions, updated web server tests. (#207)

* Updated all package versions including kotlin. Updated all web-server tests to run.

* Changed the java version of the tests. OpenDC now only supports java 19.

* small update

* test update

* new update

* updated docker version to 19

* updated docker version to 19

3 files changed, 485 insertions, 441 deletions

diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt
index 4dc1cfa8..52caea0c 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt
@@ -63,309 +63,324 @@ internal class ComputeServiceTest {
     @BeforeEach
     fun setUp() {
         scope = SimulationCoroutineScope()
-        val computeScheduler = FilterScheduler(
-            filters = listOf(ComputeFilter(), VCpuFilter(allocationRatio = 1.0), RamFilter(allocationRatio = 1.0)),
-            weighers = listOf(RamWeigher())
-        )
+        val computeScheduler =
+            FilterScheduler(
+                filters = listOf(ComputeFilter(), VCpuFilter(allocationRatio = 1.0), RamFilter(allocationRatio = 1.0)),
+                weighers = listOf(RamWeigher()),
+            )
         service = ComputeService(scope.dispatcher, computeScheduler, Duration.ofMinutes(5))
     }
 
     @Test
-    fun testClientClose() = scope.runSimulation {
-        val client = service.newClient()
+    fun testClientClose() =
+        scope.runSimulation {
+            val client = service.newClient()
 
-        assertEquals(emptyList<Flavor>(), client.queryFlavors())
-        assertEquals(emptyList<Image>(), client.queryImages())
-        assertEquals(emptyList<Server>(), client.queryServers())
+            assertEquals(emptyList<Flavor>(), client.queryFlavors())
+            assertEquals(emptyList<Image>(), client.queryImages())
+            assertEquals(emptyList<Server>(), client.queryServers())
 
-        client.close()
+            client.close()
 
-        assertThrows<IllegalStateException> { client.queryFlavors() }
-        assertThrows<IllegalStateException> { client.queryImages() }
-        assertThrows<IllegalStateException> { client.queryServers() }
+            assertThrows<IllegalStateException> { client.queryFlavors() }
+            assertThrows<IllegalStateException> { client.queryImages() }
+            assertThrows<IllegalStateException> { client.queryServers() }
 
-        assertThrows<IllegalStateException> { client.findFlavor(UUID.randomUUID()) }
-        assertThrows<IllegalStateException> { client.findImage(UUID.randomUUID()) }
-        assertThrows<IllegalStateException> { client.findServer(UUID.randomUUID()) }
+            assertThrows<IllegalStateException> { client.findFlavor(UUID.randomUUID()) }
+            assertThrows<IllegalStateException> { client.findImage(UUID.randomUUID()) }
+            assertThrows<IllegalStateException> { client.findServer(UUID.randomUUID()) }
 
-        assertThrows<IllegalStateException> { client.newFlavor("test", 1, 2) }
-        assertThrows<IllegalStateException> { client.newImage("test") }
-        assertThrows<IllegalStateException> { client.newServer("test", mockk(), mockk()) }
-    }
+            assertThrows<IllegalStateException> { client.newFlavor("test", 1, 2) }
+            assertThrows<IllegalStateException> { client.newImage("test") }
+            assertThrows<IllegalStateException> { client.newServer("test", mockk(), mockk()) }
+        }
 
     @Test
-    fun testClientCreate() = scope.runSimulation {
-        val client = service.newClient()
-
-        val flavor = client.newFlavor("test", 1, 1024)
-        assertEquals(listOf(flavor), client.queryFlavors())
-        assertEquals(flavor, client.findFlavor(flavor.uid))
-        val image = client.newImage("test")
-        assertEquals(listOf(image), client.queryImages())
-        assertEquals(image, client.findImage(image.uid))
-        val server = client.newServer("test", image, flavor, start = false)
-        assertEquals(listOf(server), client.queryServers())
-        assertEquals(server, client.findServer(server.uid))
-
-        server.delete()
-        assertNull(client.findServer(server.uid))
-
-        image.delete()
-        assertNull(client.findImage(image.uid))
-
-        flavor.delete()
-        assertNull(client.findFlavor(flavor.uid))
-
-        assertThrows<IllegalStateException> { server.start() }
-    }
+    fun testClientCreate() =
+        scope.runSimulation {
+            val client = service.newClient()
+
+            val flavor = client.newFlavor("test", 1, 1024)
+            assertEquals(listOf(flavor), client.queryFlavors())
+            assertEquals(flavor, client.findFlavor(flavor.uid))
+            val image = client.newImage("test")
+            assertEquals(listOf(image), client.queryImages())
+            assertEquals(image, client.findImage(image.uid))
+            val server = client.newServer("test", image, flavor, start = false)
+            assertEquals(listOf(server), client.queryServers())
+            assertEquals(server, client.findServer(server.uid))
+
+            server.delete()
+            assertNull(client.findServer(server.uid))
+
+            image.delete()
+            assertNull(client.findImage(image.uid))
+
+            flavor.delete()
+            assertNull(client.findFlavor(flavor.uid))
+
+            assertThrows<IllegalStateException> { server.start() }
+        }
 
     @Test
-    fun testClientOnClose() = scope.runSimulation {
-        service.close()
-        assertThrows<IllegalStateException> {
-            service.newClient()
+    fun testClientOnClose() =
+        scope.runSimulation {
+            service.close()
+            assertThrows<IllegalStateException> {
+                service.newClient()
+            }
         }
-    }
 
     @Test
-    fun testAddHost() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
+    fun testAddHost() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
 
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.UP
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.UP
 
-        assertEquals(emptySet<Host>(), service.hosts)
+            assertEquals(emptySet<Host>(), service.hosts)
 
-        service.addHost(host)
+            service.addHost(host)
 
-        verify(exactly = 1) { host.addListener(any()) }
+            verify(exactly = 1) { host.addListener(any()) }
 
-        assertEquals(1, service.hosts.size)
+            assertEquals(1, service.hosts.size)
 
-        service.removeHost(host)
+            service.removeHost(host)
 
-        verify(exactly = 1) { host.removeListener(any()) }
-    }
+            verify(exactly = 1) { host.removeListener(any()) }
+        }
 
     @Test
-    fun testAddHostDouble() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
+    fun testAddHostDouble() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
 
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.DOWN
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.DOWN
 
-        assertEquals(emptySet<Host>(), service.hosts)
+            assertEquals(emptySet<Host>(), service.hosts)
 
-        service.addHost(host)
-        service.addHost(host)
+            service.addHost(host)
+            service.addHost(host)
 
-        verify(exactly = 1) { host.addListener(any()) }
-    }
+            verify(exactly = 1) { host.addListener(any()) }
+        }
 
     @Test
-    fun testServerStartWithoutEnoughCpus() = scope.runSimulation {
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 0)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-
-        server.start()
-        delay(5L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.TERMINATED, server.state)
-    }
+    fun testServerStartWithoutEnoughCpus() =
+        scope.runSimulation {
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 0)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
+
+            server.start()
+            delay(5L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.TERMINATED, server.state)
+        }
 
     @Test
-    fun testServerStartWithoutEnoughMemory() = scope.runSimulation {
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 0, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-
-        server.start()
-        delay(5L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.TERMINATED, server.state)
-    }
+    fun testServerStartWithoutEnoughMemory() =
+        scope.runSimulation {
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 0, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
+
+            server.start()
+            delay(5L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.TERMINATED, server.state)
+        }
 
     @Test
-    fun testServerStartWithoutEnoughResources() = scope.runSimulation {
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-
-        server.start()
-        delay(5L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.TERMINATED, server.state)
-    }
+    fun testServerStartWithoutEnoughResources() =
+        scope.runSimulation {
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
+
+            server.start()
+            delay(5L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.TERMINATED, server.state)
+        }
 
     @Test
-    fun testServerCancelRequest() = scope.runSimulation {
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-
-        server.start()
-        server.stop()
-        delay(5L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.TERMINATED, server.state)
-    }
+    fun testServerCancelRequest() =
+        scope.runSimulation {
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
+
+            server.start()
+            server.stop()
+            delay(5L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.TERMINATED, server.state)
+        }
 
     @Test
-    fun testServerCannotFitOnHost() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
+    fun testServerCannotFitOnHost() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
 
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.UP
-        every { host.canFit(any()) } returns false
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.UP
+            every { host.canFit(any()) } returns false
 
-        service.addHost(host)
+            service.addHost(host)
 
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
 
-        server.start()
-        delay(10L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.PROVISIONING, server.state)
+            server.start()
+            delay(10L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.PROVISIONING, server.state)
 
-        verify { host.canFit(server) }
-    }
+            verify { host.canFit(server) }
+        }
 
     @Test
-    fun testHostAvailableAfterSomeTime() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
-        val listeners = mutableListOf<HostListener>()
+    fun testHostAvailableAfterSomeTime() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
+            val listeners = mutableListOf<HostListener>()
 
-        every { host.uid } returns UUID.randomUUID()
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.DOWN
-        every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
-        every { host.canFit(any()) } returns false
+            every { host.uid } returns UUID.randomUUID()
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.DOWN
+            every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
+            every { host.canFit(any()) } returns false
 
-        service.addHost(host)
+            service.addHost(host)
 
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
 
-        server.start()
-        delay(5L * 60 * 1000)
+            server.start()
+            delay(5L * 60 * 1000)
 
-        every { host.state } returns HostState.UP
-        listeners.forEach { it.onStateChanged(host, HostState.UP) }
+            every { host.state } returns HostState.UP
+            listeners.forEach { it.onStateChanged(host, HostState.UP) }
 
-        delay(5L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.PROVISIONING, server.state)
+            delay(5L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.PROVISIONING, server.state)
 
-        verify { host.canFit(server) }
-    }
+            verify { host.canFit(server) }
+        }
 
     @Test
-    fun testHostUnavailableAfterSomeTime() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
-        val listeners = mutableListOf<HostListener>()
+    fun testHostUnavailableAfterSomeTime() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
+            val listeners = mutableListOf<HostListener>()
 
-        every { host.uid } returns UUID.randomUUID()
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.UP
-        every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
-        every { host.canFit(any()) } returns false
+            every { host.uid } returns UUID.randomUUID()
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.UP
+            every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
+            every { host.canFit(any()) } returns false
 
-        service.addHost(host)
+            service.addHost(host)
 
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
 
-        delay(5L * 60 * 1000)
+            delay(5L * 60 * 1000)
 
-        every { host.state } returns HostState.DOWN
-        listeners.forEach { it.onStateChanged(host, HostState.DOWN) }
+            every { host.state } returns HostState.DOWN
+            listeners.forEach { it.onStateChanged(host, HostState.DOWN) }
 
-        server.start()
-        delay(5L * 60 * 1000)
-        server.reload()
-        assertEquals(ServerState.PROVISIONING, server.state)
+            server.start()
+            delay(5L * 60 * 1000)
+            server.reload()
+            assertEquals(ServerState.PROVISIONING, server.state)
 
-        verify(exactly = 0) { host.canFit(server) }
-    }
+            verify(exactly = 0) { host.canFit(server) }
+        }
 
     @Test
-    fun testServerDeploy() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
-        val listeners = mutableListOf<HostListener>()
+    fun testServerDeploy() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
+            val listeners = mutableListOf<HostListener>()
 
-        every { host.uid } returns UUID.randomUUID()
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.UP
-        every { host.canFit(any()) } returns true
-        every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
+            every { host.uid } returns UUID.randomUUID()
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.UP
+            every { host.canFit(any()) } returns true
+            every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
 
-        service.addHost(host)
+            service.addHost(host)
 
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-        val slot = slot<Server>()
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
+            val slot = slot<Server>()
 
-        val watcher = mockk<ServerWatcher>(relaxUnitFun = true)
-        server.watch(watcher)
+            val watcher = mockk<ServerWatcher>(relaxUnitFun = true)
+            server.watch(watcher)
 
-        // Start server
-        server.start()
-        delay(5L * 60 * 1000)
-        coVerify { host.spawn(capture(slot)) }
+            // Start server
+            server.start()
+            delay(5L * 60 * 1000)
+            coVerify { host.spawn(capture(slot)) }
 
-        listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.RUNNING) }
+            listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.RUNNING) }
 
-        server.reload()
-        assertEquals(ServerState.RUNNING, server.state)
+            server.reload()
+            assertEquals(ServerState.RUNNING, server.state)
 
-        verify { watcher.onStateChanged(server, ServerState.RUNNING) }
+            verify { watcher.onStateChanged(server, ServerState.RUNNING) }
 
-        // Stop server
-        listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.TERMINATED) }
+            // Stop server
+            listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.TERMINATED) }
 
-        server.reload()
-        assertEquals(ServerState.TERMINATED, server.state)
+            server.reload()
+            assertEquals(ServerState.TERMINATED, server.state)
 
-        verify { watcher.onStateChanged(server, ServerState.TERMINATED) }
-    }
+            verify { watcher.onStateChanged(server, ServerState.TERMINATED) }
+        }
 
     @Test
-    fun testServerDeployFailure() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
-        val listeners = mutableListOf<HostListener>()
-
-        every { host.uid } returns UUID.randomUUID()
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.UP
-        every { host.canFit(any()) } returns true
-        every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
-        coEvery { host.spawn(any()) } throws IllegalStateException()
-
-        service.addHost(host)
-
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-
-        server.start()
-        delay(5L * 60 * 1000)
-
-        server.reload()
-        assertEquals(ServerState.PROVISIONING, server.state)
-    }
+    fun testServerDeployFailure() =
+        scope.runSimulation {
+            val host = mockk<Host>(relaxUnitFun = true)
+            val listeners = mutableListOf<HostListener>()
+
+            every { host.uid } returns UUID.randomUUID()
+            every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
+            every { host.state } returns HostState.UP
+            every { host.canFit(any()) } returns true
+            every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
+            coEvery { host.spawn(any()) } throws IllegalStateException()
+
+            service.addHost(host)
+
+            val client = service.newClient()
+            val flavor = client.newFlavor("test", 1, 1024)
+            val image = client.newImage("test")
+            val server = client.newServer("test", image, flavor, start = false)
+
+            server.start()
+            delay(5L * 60 * 1000)
+
+            server.reload()
+            assertEquals(ServerState.PROVISIONING, server.state)
+        }
 }
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt
index f9fcd27b..6e0f11b3 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt
@@ -80,193 +80,205 @@ class ServiceServerTest {
     }
 
     @Test
-    fun testStartTerminatedServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testStartTerminatedServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceServer, 0) }
+            every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceServer, 0) }
 
-        server.start()
+            server.start()
 
-        verify(exactly = 1) { service.schedule(server) }
-        assertEquals(ServerState.PROVISIONING, server.state)
-    }
+            verify(exactly = 1) { service.schedule(server) }
+            assertEquals(ServerState.PROVISIONING, server.state)
+        }
 
     @Test
-    fun testStartDeletedServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testStartDeletedServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.DELETED)
+            server.setState(ServerState.DELETED)
 
-        assertThrows<IllegalStateException> { server.start() }
-    }
+            assertThrows<IllegalStateException> { server.start() }
+        }
 
     @Test
-    fun testStartProvisioningServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testStartProvisioningServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.PROVISIONING)
+            server.setState(ServerState.PROVISIONING)
 
-        server.start()
+            server.start()
 
-        assertEquals(ServerState.PROVISIONING, server.state)
-    }
+            assertEquals(ServerState.PROVISIONING, server.state)
+        }
 
     @Test
-    fun testStartRunningServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testStartRunningServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.RUNNING)
+            server.setState(ServerState.RUNNING)
 
-        server.start()
+            server.start()
 
-        assertEquals(ServerState.RUNNING, server.state)
-    }
+            assertEquals(ServerState.RUNNING, server.state)
+        }
 
     @Test
-    fun testStopProvisioningServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-        val request = ComputeService.SchedulingRequest(server, 0)
+    fun testStopProvisioningServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val request = ComputeService.SchedulingRequest(server, 0)
 
-        every { service.schedule(any()) } returns request
+            every { service.schedule(any()) } returns request
 
-        server.start()
-        server.stop()
+            server.start()
+            server.stop()
 
-        assertTrue(request.isCancelled)
-        assertEquals(ServerState.TERMINATED, server.state)
-    }
+            assertTrue(request.isCancelled)
+            assertEquals(ServerState.TERMINATED, server.state)
+        }
 
     @Test
-    fun testStopTerminatedServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testStopTerminatedServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.TERMINATED)
-        server.stop()
+            server.setState(ServerState.TERMINATED)
+            server.stop()
 
-        assertEquals(ServerState.TERMINATED, server.state)
-    }
+            assertEquals(ServerState.TERMINATED, server.state)
+        }
 
     @Test
-    fun testStopDeletedServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testStopDeletedServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.DELETED)
-        server.stop()
+            server.setState(ServerState.DELETED)
+            server.stop()
 
-        assertEquals(ServerState.DELETED, server.state)
-    }
+            assertEquals(ServerState.DELETED, server.state)
+        }
 
     @Test
-    fun testStopRunningServer() = runSimulation {
-        val service = mockk<ComputeService>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-        val host = mockk<Host>(relaxUnitFun = true)
-
-        server.setState(ServerState.RUNNING)
-        server.host = host
-        server.stop()
-        yield()
-
-        verify { host.stop(server) }
-    }
+    fun testStopRunningServer() =
+        runSimulation {
+            val service = mockk<ComputeService>()
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val host = mockk<Host>(relaxUnitFun = true)
+
+            server.setState(ServerState.RUNNING)
+            server.host = host
+            server.stop()
+            yield()
+
+            verify { host.stop(server) }
+        }
 
     @Test
-    fun testDeleteProvisioningServer() = runSimulation {
-        val service = mockk<ComputeService>(relaxUnitFun = true)
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-        val request = ComputeService.SchedulingRequest(server, 0)
+    fun testDeleteProvisioningServer() =
+        runSimulation {
+            val service = mockk<ComputeService>(relaxUnitFun = true)
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val request = ComputeService.SchedulingRequest(server, 0)
 
-        every { service.schedule(any()) } returns request
+            every { service.schedule(any()) } returns request
 
-        server.start()
-        server.delete()
+            server.start()
+            server.delete()
 
-        assertTrue(request.isCancelled)
-        assertEquals(ServerState.DELETED, server.state)
-        verify { service.delete(server) }
-    }
+            assertTrue(request.isCancelled)
+            assertEquals(ServerState.DELETED, server.state)
+            verify { service.delete(server) }
+        }
 
     @Test
-    fun testDeleteTerminatedServer() = runSimulation {
-        val service = mockk<ComputeService>(relaxUnitFun = true)
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testDeleteTerminatedServer() =
+        runSimulation {
+            val service = mockk<ComputeService>(relaxUnitFun = true)
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.TERMINATED)
-        server.delete()
+            server.setState(ServerState.TERMINATED)
+            server.delete()
 
-        assertEquals(ServerState.DELETED, server.state)
+            assertEquals(ServerState.DELETED, server.state)
 
-        verify { service.delete(server) }
-    }
+            verify { service.delete(server) }
+        }
 
     @Test
-    fun testDeleteDeletedServer() = runSimulation {
-        val service = mockk<ComputeService>(relaxUnitFun = true)
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+    fun testDeleteDeletedServer() =
+        runSimulation {
+            val service = mockk<ComputeService>(relaxUnitFun = true)
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.setState(ServerState.DELETED)
-        server.delete()
+            server.setState(ServerState.DELETED)
+            server.delete()
 
-        assertEquals(ServerState.DELETED, server.state)
-    }
+            assertEquals(ServerState.DELETED, server.state)
+        }
 
     @Test
-    fun testDeleteRunningServer() = runSimulation {
-        val service = mockk<ComputeService>(relaxUnitFun = true)
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-        val host = mockk<Host>(relaxUnitFun = true)
-
-        server.setState(ServerState.RUNNING)
-        server.host = host
-        server.delete()
-        yield()
-
-        verify { host.delete(server) }
-        verify { service.delete(server) }
-    }
+    fun testDeleteRunningServer() =
+        runSimulation {
+            val service = mockk<ComputeService>(relaxUnitFun = true)
+            val uid = UUID.randomUUID()
+            val flavor = mockFlavor()
+            val image = mockImage()
+            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val host = mockk<Host>(relaxUnitFun = true)
+
+            server.setState(ServerState.RUNNING)
+            server.host = host
+            server.delete()
+            yield()
+
+            verify { host.delete(server) }
+            verify { service.delete(server) }
+        }
 
     private fun mockFlavor(): ServiceFlavor {
         val flavor = mockk<ServiceFlavor>()
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt
index 4af6f7ec..a48052a1 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt
@@ -57,7 +57,7 @@ internal class FilterSchedulerTest {
             FilterScheduler(
                 filters = emptyList(),
                 weighers = emptyList(),
-                subsetSize = 0
+                subsetSize = 0,
             )
         }
 
@@ -65,17 +65,18 @@ internal class FilterSchedulerTest {
             FilterScheduler(
                 filters = emptyList(),
                 weighers = emptyList(),
-                subsetSize = -2
+                subsetSize = -2,
             )
         }
     }
 
     @Test
     fun testNoHosts() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = emptyList(),
+            )
 
         val server = mockk<Server>()
         every { server.flavor.cpuCount } returns 2
@@ -86,10 +87,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testNoFiltersAndSchedulers() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = emptyList(),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.DOWN
@@ -107,18 +109,19 @@ internal class FilterSchedulerTest {
         // Make sure we get the first host both times
         assertAll(
             { assertEquals(hostA, scheduler.select(server)) },
-            { assertEquals(hostA, scheduler.select(server)) }
+            { assertEquals(hostA, scheduler.select(server)) },
         )
     }
 
     @Test
     fun testNoFiltersAndSchedulersRandom() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = emptyList(),
-            subsetSize = Int.MAX_VALUE,
-            random = Random(1)
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = emptyList(),
+                subsetSize = Int.MAX_VALUE,
+                random = Random(1),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.DOWN
@@ -136,16 +139,17 @@ internal class FilterSchedulerTest {
         // Make sure we get the first host both times
         assertAll(
             { assertEquals(hostB, scheduler.select(server)) },
-            { assertEquals(hostA, scheduler.select(server)) }
+            { assertEquals(hostA, scheduler.select(server)) },
         )
     }
 
     @Test
     fun testHostIsDown() {
-        val scheduler = FilterScheduler(
-            filters = listOf(ComputeFilter()),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(ComputeFilter()),
+                weighers = emptyList(),
+            )
 
         val host = mockk<HostView>()
         every { host.host.state } returns HostState.DOWN
@@ -161,10 +165,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testHostIsUp() {
-        val scheduler = FilterScheduler(
-            filters = listOf(ComputeFilter()),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(ComputeFilter()),
+                weighers = emptyList(),
+            )
 
         val host = mockk<HostView>()
         every { host.host.state } returns HostState.UP
@@ -180,10 +185,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testRamFilter() {
-        val scheduler = FilterScheduler(
-            filters = listOf(RamFilter(1.0)),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(RamFilter(1.0)),
+                weighers = emptyList(),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -207,10 +213,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testRamFilterOvercommit() {
-        val scheduler = FilterScheduler(
-            filters = listOf(RamFilter(1.5)),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(RamFilter(1.5)),
+                weighers = emptyList(),
+            )
 
         val host = mockk<HostView>()
         every { host.host.state } returns HostState.UP
@@ -228,10 +235,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testVCpuFilter() {
-        val scheduler = FilterScheduler(
-            filters = listOf(VCpuFilter(1.0)),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(VCpuFilter(1.0)),
+                weighers = emptyList(),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -255,10 +263,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testVCpuFilterOvercommit() {
-        val scheduler = FilterScheduler(
-            filters = listOf(VCpuFilter(16.0)),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(VCpuFilter(16.0)),
+                weighers = emptyList(),
+            )
 
         val host = mockk<HostView>()
         every { host.host.state } returns HostState.UP
@@ -276,10 +285,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testVCpuCapacityFilter() {
-        val scheduler = FilterScheduler(
-            filters = listOf(VCpuCapacityFilter()),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(VCpuCapacityFilter()),
+                weighers = emptyList(),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -304,10 +314,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testInstanceCountFilter() {
-        val scheduler = FilterScheduler(
-            filters = listOf(InstanceCountFilter(limit = 2)),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(InstanceCountFilter(limit = 2)),
+                weighers = emptyList(),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -331,10 +342,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testAffinityFilter() {
-        val scheduler = FilterScheduler(
-            filters = listOf(SameHostFilter()),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(SameHostFilter()),
+                weighers = emptyList(),
+            )
 
         val serverA = mockk<Server>()
         every { serverA.uid } returns UUID.randomUUID()
@@ -370,10 +382,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testAntiAffinityFilter() {
-        val scheduler = FilterScheduler(
-            filters = listOf(DifferentHostFilter()),
-            weighers = emptyList()
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = listOf(DifferentHostFilter()),
+                weighers = emptyList(),
+            )
 
         val serverA = mockk<Server>()
         every { serverA.uid } returns UUID.randomUUID()
@@ -409,10 +422,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testRamWeigher() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = listOf(RamWeigher(1.5))
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = listOf(RamWeigher(1.5)),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -436,10 +450,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testCoreRamWeigher() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = listOf(CoreRamWeigher(1.5))
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = listOf(CoreRamWeigher(1.5)),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -463,10 +478,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testVCpuWeigher() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = listOf(VCpuWeigher(16.0))
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = listOf(VCpuWeigher(16.0)),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -490,10 +506,11 @@ internal class FilterSchedulerTest {
 
     @Test
     fun testInstanceCountWeigher() {
-        val scheduler = FilterScheduler(
-            filters = emptyList(),
-            weighers = listOf(InstanceCountWeigher(multiplier = -1.0))
-        )
+        val scheduler =
+            FilterScheduler(
+                filters = emptyList(),
+                weighers = listOf(InstanceCountWeigher(multiplier = -1.0)),
+            )
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP