From 3363df4c72a064e590ca98f8e01832cfa4e15a3f Mon Sep 17 00:00:00 2001 From: Dante Niewenhuis Date: Tue, 27 Aug 2024 13:48:46 +0200 Subject: Renamed input files and internally server is changed to task (#246) * Updated SimTrace to use a single ArrayDeque instead of three separate lists for deadline, cpuUsage, and coreCount * Renamed input files to tasks.parquet and fragments.parquet. Renamed server to task. OpenDC nows exports tasks.parquet instead of server.parquet --- .../opendc/compute/service/ComputeServiceTest.kt | 72 ++-- .../opendc/compute/service/ServiceServerTest.kt | 298 -------------- .../org/opendc/compute/service/ServiceTaskTest.kt | 442 +++++++++++++++++++++ .../service/scheduler/FilterSchedulerTest.kt | 176 ++++---- 4 files changed, 566 insertions(+), 422 deletions(-) delete mode 100644 opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt create mode 100644 opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceTaskTest.kt (limited to 'opendc-compute/opendc-compute-service/src/test') 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 32d01660..e48244f0 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 @@ -36,9 +36,9 @@ import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows import org.opendc.compute.api.Flavor import org.opendc.compute.api.Image -import org.opendc.compute.api.Server -import org.opendc.compute.api.ServerState -import org.opendc.compute.api.ServerWatcher +import org.opendc.compute.api.Task +import org.opendc.compute.api.TaskState +import org.opendc.compute.api.TaskWatcher import org.opendc.compute.service.driver.Host import org.opendc.compute.service.driver.HostListener import org.opendc.compute.service.driver.HostModel @@ -78,21 +78,21 @@ internal class ComputeServiceTest { assertEquals(emptyList(), client.queryFlavors()) assertEquals(emptyList(), client.queryImages()) - assertEquals(emptyList(), client.queryServers()) + assertEquals(emptyList(), client.queryTasks()) client.close() assertThrows { client.queryFlavors() } assertThrows { client.queryImages() } - assertThrows { client.queryServers() } + assertThrows { client.queryTasks() } assertThrows { client.findFlavor(UUID.randomUUID()) } assertThrows { client.findImage(UUID.randomUUID()) } - assertThrows { client.findServer(UUID.randomUUID()) } + assertThrows { client.findTask(UUID.randomUUID()) } assertThrows { client.newFlavor("test", 1, 2) } assertThrows { client.newImage("test") } - assertThrows { client.newServer("test", mockk(), mockk()) } + assertThrows { client.newTask("test", mockk(), mockk()) } } @Test @@ -106,12 +106,12 @@ internal class ComputeServiceTest { 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)) + val server = client.newTask("test", image, flavor, start = false) + assertEquals(listOf(server), client.queryTasks()) + assertEquals(server, client.findTask(server.uid)) server.delete() - assertNull(client.findServer(server.uid)) + assertNull(client.findTask(server.uid)) image.delete() assertNull(client.findImage(image.uid)) @@ -174,12 +174,12 @@ internal class ComputeServiceTest { 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) + val server = client.newTask("test", image, flavor, start = false) server.start() delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.TERMINATED, server.state) + assertEquals(TaskState.TERMINATED, server.state) } @Test @@ -188,12 +188,12 @@ internal class ComputeServiceTest { 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) + val server = client.newTask("test", image, flavor, start = false) server.start() delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.TERMINATED, server.state) + assertEquals(TaskState.TERMINATED, server.state) } @Test @@ -202,12 +202,12 @@ internal class ComputeServiceTest { 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 server = client.newTask("test", image, flavor, start = false) server.start() delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.TERMINATED, server.state) + assertEquals(TaskState.TERMINATED, server.state) } @Test @@ -216,13 +216,13 @@ internal class ComputeServiceTest { 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 server = client.newTask("test", image, flavor, start = false) server.start() server.stop() delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.TERMINATED, server.state) + assertEquals(TaskState.TERMINATED, server.state) } @Test @@ -239,12 +239,12 @@ internal class ComputeServiceTest { 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 server = client.newTask("test", image, flavor, start = false) server.start() delay(10L * 60 * 1000) server.reload() - assertEquals(ServerState.PROVISIONING, server.state) + assertEquals(TaskState.PROVISIONING, server.state) verify { host.canFit(server) } } @@ -266,7 +266,7 @@ internal class ComputeServiceTest { 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 server = client.newTask("test", image, flavor, start = false) server.start() delay(5L * 60 * 1000) @@ -276,7 +276,7 @@ internal class ComputeServiceTest { delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.PROVISIONING, server.state) + assertEquals(TaskState.PROVISIONING, server.state) verify { host.canFit(server) } } @@ -298,7 +298,7 @@ internal class ComputeServiceTest { 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 server = client.newTask("test", image, flavor, start = false) delay(5L * 60 * 1000) @@ -308,7 +308,7 @@ internal class ComputeServiceTest { server.start() delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.PROVISIONING, server.state) + assertEquals(TaskState.PROVISIONING, server.state) verify(exactly = 0) { host.canFit(server) } } @@ -330,10 +330,10 @@ internal class ComputeServiceTest { 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() + val server = client.newTask("test", image, flavor, start = false) + val slot = slot() - val watcher = mockk(relaxUnitFun = true) + val watcher = mockk(relaxUnitFun = true) server.watch(watcher) // Start server @@ -341,20 +341,20 @@ internal class ComputeServiceTest { 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, TaskState.RUNNING) } server.reload() - assertEquals(ServerState.RUNNING, server.state) + assertEquals(TaskState.RUNNING, server.state) - verify { watcher.onStateChanged(server, ServerState.RUNNING) } + verify { watcher.onStateChanged(server, TaskState.RUNNING) } // Stop server - listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.TERMINATED) } + listeners.forEach { it.onStateChanged(host, slot.captured, TaskState.TERMINATED) } server.reload() - assertEquals(ServerState.TERMINATED, server.state) + assertEquals(TaskState.TERMINATED, server.state) - verify { watcher.onStateChanged(server, ServerState.TERMINATED) } + verify { watcher.onStateChanged(server, TaskState.TERMINATED) } } @Test @@ -375,12 +375,12 @@ internal class ComputeServiceTest { 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 server = client.newTask("test", image, flavor, start = false) server.start() delay(5L * 60 * 1000) server.reload() - assertEquals(ServerState.PROVISIONING, server.state) + assertEquals(TaskState.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 deleted file mode 100644 index b420ee3b..00000000 --- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt +++ /dev/null @@ -1,298 +0,0 @@ -/* - * Copyright (c) 2021 AtLarge Research - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -package org.opendc.compute.service - -import io.mockk.every -import io.mockk.mockk -import io.mockk.verify -import kotlinx.coroutines.yield -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNotEquals -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows -import org.opendc.compute.api.Server -import org.opendc.compute.api.ServerState -import org.opendc.compute.service.driver.Host -import org.opendc.simulator.kotlin.runSimulation -import java.util.UUID - -/** - * Test suite for the [ServiceServer] implementation. - */ -class ServiceServerTest { - @Test - fun testEquality() { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - - val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - val b = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - assertEquals(a, b) - } - - @Test - fun testInequalityWithDifferentType() { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - val b = mockk(relaxUnitFun = true) - every { b.uid } returns UUID.randomUUID() - - assertNotEquals(a, b) - } - - @Test - fun testInequalityWithIncorrectType() { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - assertNotEquals(a, Unit) - } - - @Test - fun testStartTerminatedServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceServer, 0) } - - server.start() - - verify(exactly = 1) { service.schedule(server) } - assertEquals(ServerState.PROVISIONING, server.state) - } - - @Test - fun testStartDeletedServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.DELETED) - - assertThrows { server.start() } - } - - @Test - fun testStartProvisioningServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.PROVISIONING) - - server.start() - - assertEquals(ServerState.PROVISIONING, server.state) - } - - @Test - fun testStartRunningServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.RUNNING) - - server.start() - - assertEquals(ServerState.RUNNING, server.state) - } - - @Test - fun testStopProvisioningServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - val request = ComputeService.SchedulingRequest(server, 0) - - every { service.schedule(any()) } returns request - - server.start() - server.stop() - - assertTrue(request.isCancelled) - assertEquals(ServerState.TERMINATED, server.state) - } - - @Test - fun testStopTerminatedServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.TERMINATED) - server.stop() - - assertEquals(ServerState.TERMINATED, server.state) - } - - @Test - fun testStopDeletedServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.DELETED) - server.stop() - - assertEquals(ServerState.DELETED, server.state) - } - - @Test - fun testStopRunningServer() = - runSimulation { - val service = mockk() - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - val host = mockk(relaxUnitFun = true) - - server.setState(ServerState.RUNNING) - server.host = host - server.stop() - yield() - - verify { host.stop(server) } - } - - @Test - fun testDeleteProvisioningServer() = - runSimulation { - val service = mockk(relaxUnitFun = true) - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - val request = ComputeService.SchedulingRequest(server, 0) - - every { service.schedule(any()) } returns request - - server.start() - server.delete() - - assertTrue(request.isCancelled) - assertEquals(ServerState.DELETED, server.state) - verify { service.delete(server) } - } - - @Test - fun testDeleteTerminatedServer() = - runSimulation { - val service = mockk(relaxUnitFun = true) - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.TERMINATED) - server.delete() - - assertEquals(ServerState.DELETED, server.state) - - verify { service.delete(server) } - } - - @Test - fun testDeleteDeletedServer() = - runSimulation { - val service = mockk(relaxUnitFun = true) - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - - server.setState(ServerState.DELETED) - server.delete() - - assertEquals(ServerState.DELETED, server.state) - } - - @Test - fun testDeleteRunningServer() = - runSimulation { - val service = mockk(relaxUnitFun = true) - val uid = UUID.randomUUID() - val flavor = mockFlavor() - val image = mockImage() - val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf()) - val host = mockk(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() - every { flavor.name } returns "c5.large" - every { flavor.uid } returns UUID.randomUUID() - every { flavor.coreCount } returns 2 - every { flavor.memorySize } returns 4096 - return flavor - } - - private fun mockImage(): ServiceImage { - val image = mockk() - every { image.name } returns "ubuntu-20.04" - every { image.uid } returns UUID.randomUUID() - return image - } -} diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceTaskTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceTaskTest.kt new file mode 100644 index 00000000..e77665fe --- /dev/null +++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceTaskTest.kt @@ -0,0 +1,442 @@ +/* + * Copyright (c) 2021 AtLarge Research + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package org.opendc.compute.service + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import kotlinx.coroutines.yield +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNotEquals +import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.assertThrows +import org.opendc.compute.api.Task +import org.opendc.compute.api.TaskState +import org.opendc.compute.service.driver.Host +import org.opendc.simulator.kotlin.runSimulation +import java.util.UUID + +/** + * Test suite for the [ServiceTask] implementation. + */ +class ServiceTaskTest { + @Test + fun testEquality() { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + + val a = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + val b = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + assertEquals(a, b) + } + + @Test + fun testInequalityWithDifferentType() { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val a = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + val b = mockk(relaxUnitFun = true) + every { b.uid } returns UUID.randomUUID() + + assertNotEquals(a, b) + } + + @Test + fun testInequalityWithIncorrectType() { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val a = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + assertNotEquals(a, Unit) + } + + @Test + fun testStartTerminatedServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceTask, 0) } + + server.start() + + verify(exactly = 1) { service.schedule(server) } + assertEquals(TaskState.PROVISIONING, server.state) + } + + @Test + fun testStartDeletedServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.DELETED) + + assertThrows { server.start() } + } + + @Test + fun testStartProvisioningServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.PROVISIONING) + + server.start() + + assertEquals(TaskState.PROVISIONING, server.state) + } + + @Test + fun testStartRunningServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.RUNNING) + + server.start() + + assertEquals(TaskState.RUNNING, server.state) + } + + @Test + fun testStopProvisioningServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + val request = ComputeService.SchedulingRequest(server, 0) + + every { service.schedule(any()) } returns request + + server.start() + server.stop() + + assertTrue(request.isCancelled) + assertEquals(TaskState.TERMINATED, server.state) + } + + @Test + fun testStopTerminatedServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.TERMINATED) + server.stop() + + assertEquals(TaskState.TERMINATED, server.state) + } + + @Test + fun testStopDeletedServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.DELETED) + server.stop() + + assertEquals(TaskState.DELETED, server.state) + } + + @Test + fun testStopRunningServer() = + runSimulation { + val service = mockk() + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + val host = mockk(relaxUnitFun = true) + + server.setState(TaskState.RUNNING) + server.host = host + server.stop() + yield() + + verify { host.stop(server) } + } + + @Test + fun testDeleteProvisioningServer() = + runSimulation { + val service = mockk(relaxUnitFun = true) + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + val request = ComputeService.SchedulingRequest(server, 0) + + every { service.schedule(any()) } returns request + + server.start() + server.delete() + + assertTrue(request.isCancelled) + assertEquals(TaskState.DELETED, server.state) + verify { service.delete(server) } + } + + @Test + fun testDeleteTerminatedServer() = + runSimulation { + val service = mockk(relaxUnitFun = true) + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.TERMINATED) + server.delete() + + assertEquals(TaskState.DELETED, server.state) + + verify { service.delete(server) } + } + + @Test + fun testDeleteDeletedServer() = + runSimulation { + val service = mockk(relaxUnitFun = true) + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + + server.setState(TaskState.DELETED) + server.delete() + + assertEquals(TaskState.DELETED, server.state) + } + + @Test + fun testDeleteRunningServer() = + runSimulation { + val service = mockk(relaxUnitFun = true) + val uid = UUID.randomUUID() + val flavor = mockFlavor() + val image = mockImage() + val server = + ServiceTask( + service, + uid, + "test", + flavor, + image, + mutableMapOf(), + mutableMapOf(), + ) + val host = mockk(relaxUnitFun = true) + + server.setState(TaskState.RUNNING) + server.host = host + server.delete() + yield() + + verify { host.delete(server) } + verify { service.delete(server) } + } + + private fun mockFlavor(): ServiceFlavor { + val flavor = mockk() + every { flavor.name } returns "c5.large" + every { flavor.uid } returns UUID.randomUUID() + every { flavor.coreCount } returns 2 + every { flavor.memorySize } returns 4096 + return flavor + } + + private fun mockImage(): ServiceImage { + val image = mockk() + every { image.name } returns "ubuntu-20.04" + every { image.uid } returns UUID.randomUUID() + return image + } +} 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 3bcecf9b..2478bf82 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 @@ -29,7 +29,7 @@ import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertAll import org.junit.jupiter.api.assertThrows -import org.opendc.compute.api.Server +import org.opendc.compute.api.Task import org.opendc.compute.service.HostView import org.opendc.compute.service.driver.HostModel import org.opendc.compute.service.driver.HostState @@ -78,11 +78,11 @@ internal class FilterSchedulerTest { weighers = emptyList(), ) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertNull(scheduler.select(server)) + assertNull(scheduler.select(task)) } @Test @@ -102,14 +102,14 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 // Make sure we get the first host both times assertAll( - { assertEquals(hostA, scheduler.select(server)) }, - { assertEquals(hostA, scheduler.select(server)) }, + { assertEquals(hostA, scheduler.select(task)) }, + { assertEquals(hostA, scheduler.select(task)) }, ) } @@ -132,14 +132,14 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 // Make sure we get the first host both times assertAll( - { assertEquals(hostB, scheduler.select(server)) }, - { assertEquals(hostA, scheduler.select(server)) }, + { assertEquals(hostB, scheduler.select(task)) }, + { assertEquals(hostA, scheduler.select(task)) }, ) } @@ -156,11 +156,11 @@ internal class FilterSchedulerTest { scheduler.addHost(host) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertNull(scheduler.select(server)) + assertNull(scheduler.select(task)) } @Test @@ -176,11 +176,11 @@ internal class FilterSchedulerTest { scheduler.addHost(host) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(host, scheduler.select(server)) + assertEquals(host, scheduler.select(task)) } @Test @@ -204,11 +204,11 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } @Test @@ -226,11 +226,11 @@ internal class FilterSchedulerTest { scheduler.addHost(host) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 2300 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 2300 - assertNull(scheduler.select(server)) + assertNull(scheduler.select(task)) } @Test @@ -254,11 +254,11 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } @Test @@ -276,11 +276,11 @@ internal class FilterSchedulerTest { scheduler.addHost(host) - val server = mockk() - every { server.flavor.coreCount } returns 8 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 8 + every { task.flavor.memorySize } returns 1024 - assertNull(scheduler.select(server)) + assertNull(scheduler.select(task)) } // TODO: fix when schedulers are reworked @@ -305,12 +305,12 @@ internal class FilterSchedulerTest { scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 - every { server.flavor.meta } returns mapOf("cpu-capacity" to 2 * 3200.0) + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 + every { task.flavor.meta } returns mapOf("cpu-capacity" to 2 * 3200.0) - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } @Test @@ -334,11 +334,11 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } @Test @@ -349,10 +349,10 @@ internal class FilterSchedulerTest { weighers = emptyList(), ) - val serverA = mockk() - every { serverA.uid } returns UUID.randomUUID() - every { serverA.flavor.coreCount } returns 2 - every { serverA.flavor.memorySize } returns 1024 + val taskA = mockk() + every { taskA.uid } returns UUID.randomUUID() + every { taskA.flavor.coreCount } returns 2 + every { taskA.flavor.memorySize } returns 1024 val hostA = mockk() every { hostA.host.state } returns HostState.UP @@ -363,22 +363,22 @@ internal class FilterSchedulerTest { val hostB = mockk() every { hostB.host.state } returns HostState.UP every { hostB.host.model } returns HostModel(4 * 2600.0, 1, 4, 2048) - every { hostB.host.instances } returns setOf(serverA) + every { hostB.host.instances } returns setOf(taskA) every { hostB.provisionedCores } returns 0 scheduler.addHost(hostA) scheduler.addHost(hostB) - val serverB = mockk() - every { serverB.flavor.coreCount } returns 2 - every { serverB.flavor.memorySize } returns 1024 - every { serverB.meta } returns emptyMap() + val taskB = mockk() + every { taskB.flavor.coreCount } returns 2 + every { taskB.flavor.memorySize } returns 1024 + every { taskB.meta } returns emptyMap() - assertEquals(hostA, scheduler.select(serverB)) + assertEquals(hostA, scheduler.select(taskB)) - every { serverB.meta } returns mapOf("scheduler_hint:same_host" to setOf(serverA.uid)) + every { taskB.meta } returns mapOf("scheduler_hint:same_host" to setOf(taskA.uid)) - assertEquals(hostB, scheduler.select(serverB)) + assertEquals(hostB, scheduler.select(taskB)) } @Test @@ -389,15 +389,15 @@ internal class FilterSchedulerTest { weighers = emptyList(), ) - val serverA = mockk() - every { serverA.uid } returns UUID.randomUUID() - every { serverA.flavor.coreCount } returns 2 - every { serverA.flavor.memorySize } returns 1024 + val taskA = mockk() + every { taskA.uid } returns UUID.randomUUID() + every { taskA.flavor.coreCount } returns 2 + every { taskA.flavor.memorySize } returns 1024 val hostA = mockk() every { hostA.host.state } returns HostState.UP every { hostA.host.model } returns HostModel(4 * 2600.0, 1, 4, 2048) - every { hostA.host.instances } returns setOf(serverA) + every { hostA.host.instances } returns setOf(taskA) every { hostA.provisionedCores } returns 3 val hostB = mockk() @@ -409,16 +409,16 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val serverB = mockk() - every { serverB.flavor.coreCount } returns 2 - every { serverB.flavor.memorySize } returns 1024 - every { serverB.meta } returns emptyMap() + val taskB = mockk() + every { taskB.flavor.coreCount } returns 2 + every { taskB.flavor.memorySize } returns 1024 + every { taskB.meta } returns emptyMap() - assertEquals(hostA, scheduler.select(serverB)) + assertEquals(hostA, scheduler.select(taskB)) - every { serverB.meta } returns mapOf("scheduler_hint:different_host" to setOf(serverA.uid)) + every { taskB.meta } returns mapOf("scheduler_hint:different_host" to setOf(taskA.uid)) - assertEquals(hostB, scheduler.select(serverB)) + assertEquals(hostB, scheduler.select(taskB)) } @Test @@ -442,11 +442,11 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostA, scheduler.select(server)) + assertEquals(hostA, scheduler.select(task)) } // TODO: fix test when updating schedulers @@ -471,11 +471,11 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } @Test @@ -499,11 +499,11 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } @Test @@ -527,10 +527,10 @@ internal class FilterSchedulerTest { scheduler.addHost(hostA) scheduler.addHost(hostB) - val server = mockk() - every { server.flavor.coreCount } returns 2 - every { server.flavor.memorySize } returns 1024 + val task = mockk() + every { task.flavor.coreCount } returns 2 + every { task.flavor.memorySize } returns 1024 - assertEquals(hostB, scheduler.select(server)) + assertEquals(hostB, scheduler.select(task)) } } -- cgit v1.2.3