diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index f2f1bd6263e917ff4c9c78f7d851b61cacc6c57f..995c925979bb482ffbeb7966542eebfbdb66017b 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -255,6 +255,10 @@ test-theodolite:
- build-theodolite-jvm
#- build-theodolite-native
script: ./gradlew test --stacktrace
+ artifacts:
+ reports:
+ junit:
+ - "theodolite-quarkus/**/build/test-results/test/TEST-*.xml"
# Disabled for now
.ktlint-theodolite:
diff --git a/theodolite-quarkus/build.gradle b/theodolite-quarkus/build.gradle
index 8c0a13d1f24cfde01c8604285c49d3f48fe6a3b7..21f65678407568bb8d519e4c7e6f4bacff90205f 100644
--- a/theodolite-quarkus/build.gradle
+++ b/theodolite-quarkus/build.gradle
@@ -27,10 +27,10 @@ dependencies {
implementation 'khttp:khttp:1.0.0'
compile 'junit:junit:4.12'
-
testImplementation 'io.quarkus:quarkus-junit5'
testImplementation 'io.rest-assured:rest-assured'
testImplementation 'org.junit-pioneer:junit-pioneer:1.4.0'
+ testImplementation (group: 'io.fabric8', name: 'kubernetes-server-mock', version: '5.4.1'){force = true}
}
group 'theodolite'
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt
index fe1b95f95c74efe77913ea435dd1ac896805b065..0367fa40d45ae9e357c43856dc05d19740bd94b9 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt
@@ -29,7 +29,7 @@ class ExecutionStateHandler(context: CustomResourceDefinitionContext, val client
private fun getDurationLambda() = { cr: CustomResource ->
var execState = ""
- if (cr is ExecutionCRD) { execState = cr.status.executionState }
+ if (cr is ExecutionCRD) { execState = cr.status.executionDuration }
execState
}
@@ -43,9 +43,9 @@ class ExecutionStateHandler(context: CustomResourceDefinitionContext, val client
return States.values().firstOrNull { it.value == status }
}
- fun setDurationState(resourceName: String, duration: Duration) {
+ fun setDurationState(resourceName: String, duration: Duration): Boolean {
setState(resourceName) { cr -> if (cr is ExecutionCRD) cr.status.executionDuration = durationToK8sString(duration); cr }
- blockUntilStateIsSet(resourceName, durationToK8sString(duration), getDurationLambda())
+ return blockUntilStateIsSet(resourceName, durationToK8sString(duration), getDurationLambda())
}
fun getDurationState(resourceName: String): String? {
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/CustomResourceWrapper.kt
similarity index 52%
rename from theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt
rename to theodolite-quarkus/src/main/kotlin/theodolite/k8s/CustomResourceWrapper.kt
index 56452d74968db0fd4c939f44f3ed8a7abbe7b928..9d879ef131d49c8b4491f94dd89dde5437b0bf6e 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/CustomResourceWrapper.kt
@@ -2,12 +2,11 @@ package theodolite.k8s
import io.fabric8.kubernetes.client.CustomResource
import io.fabric8.kubernetes.client.NamespacedKubernetesClient
+import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext
import mu.KotlinLogging
private val logger = KotlinLogging.logger {}
-
-class ServiceMonitorWrapper(private val serviceMonitor: Map<String, String>) : CustomResource() {
-
+class CustomResourceWrapper(val crAsMap: Map<String, String>, private val context: CustomResourceDefinitionContext) : CustomResource() {
/**
* Deploy a service monitor
*
@@ -16,14 +15,9 @@ class ServiceMonitorWrapper(private val serviceMonitor: Map<String, String>) : C
* @throws java.io.IOException if the resource could not be deployed.
*/
fun deploy(client: NamespacedKubernetesClient) {
- val serviceMonitorContext = K8sContextFactory().create(
- api = "v1",
- scope = "Namespaced",
- group = "monitoring.coreos.com",
- plural = "servicemonitors"
- )
- client.customResource(serviceMonitorContext)
- .createOrReplace(client.configuration.namespace, this.serviceMonitor as Map<String, Any>)
+
+ client.customResource(this.context)
+ .createOrReplace(client.configuration.namespace, this.crAsMap as Map<String, Any>)
}
/**
@@ -32,15 +26,9 @@ class ServiceMonitorWrapper(private val serviceMonitor: Map<String, String>) : C
* @param client a namespaced Kubernetes client which are used to delete the CR object.
*/
fun delete(client: NamespacedKubernetesClient) {
- val serviceMonitorContext = K8sContextFactory().create(
- api = "v1",
- scope = "Namespaced",
- group = "monitoring.coreos.com",
- plural = "servicemonitors"
- )
try {
- client.customResource(serviceMonitorContext)
- .delete(client.configuration.namespace, this.getServiceMonitorName())
+ client.customResource(this.context)
+ .delete(client.configuration.namespace, this.getName())
} catch (e: Exception) {
logger.warn { "Could not delete service monitor" }
}
@@ -49,13 +37,13 @@ class ServiceMonitorWrapper(private val serviceMonitor: Map<String, String>) : C
/**
* @throws NullPointerException if name or metadata is null
*/
- private fun getServiceMonitorName(): String {
- val smAsMap = this.serviceMonitor["metadata"]!! as Map<String, String>
- return smAsMap["name"]!!
+ fun getName(): String {
+ val metadataAsMap = this.crAsMap["metadata"]!! as Map<String, String>
+ return metadataAsMap["name"]!!
}
fun getLabels(): Map<String, String>{
- val smAsMap = this.serviceMonitor["metadata"]!! as Map<String, String>
- return smAsMap["labels"]!! as Map<String, String>
+ val metadataAsMap = this.crAsMap["metadata"]!! as Map<String, String>
+ return metadataAsMap["labels"]!! as Map<String, String>
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sManager.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sManager.kt
index c58225bf855c70a5a7057132617418a89b0816a8..77350868500ffa974ab2b9fadfb8cfd915c8aaf2 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sManager.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sManager.kt
@@ -31,7 +31,7 @@ class K8sManager(private val client: NamespacedKubernetesClient) {
this.client.configMaps().createOrReplace(resource)
is StatefulSet ->
this.client.apps().statefulSets().createOrReplace(resource)
- is ServiceMonitorWrapper -> resource.deploy(client)
+ is CustomResourceWrapper -> resource.deploy(client)
else -> throw IllegalArgumentException("Unknown Kubernetes resource.")
}
}
@@ -58,7 +58,7 @@ class K8sManager(private val client: NamespacedKubernetesClient) {
blockUntilPodsDeleted(label)
logger.info { "StatefulSet '$resource.metadata.name' deleted." }
}
- is ServiceMonitorWrapper -> resource.delete(client)
+ is CustomResourceWrapper -> resource.delete(client)
else -> throw IllegalArgumentException("Unknown Kubernetes resource.")
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt
index fd5ec3b2e744b5e096187626a2fd756f71f87e67..ab4bef3eaa0d93032ab9edacb510ba1b750e2dd6 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt
@@ -5,6 +5,7 @@ import io.fabric8.kubernetes.api.model.KubernetesResource
import io.fabric8.kubernetes.api.model.Service
import io.fabric8.kubernetes.api.model.apps.Deployment
import io.fabric8.kubernetes.client.NamespacedKubernetesClient
+import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext
import mu.KotlinLogging
import theodolite.util.YamlParser
@@ -26,22 +27,56 @@ class K8sResourceLoader(private val client: NamespacedKubernetesClient) {
return loadGenericResource(path) { x: String -> client.services().load(x).get() }
}
+
/**
* Parses a CustomResource from a yaml
* @param path of the yaml file
- * @return CustomResource from fabric8
+ * @param context specific crd context for this custom resource
+ * @return CustomResourceWrapper from fabric8
*/
- private fun loadServiceMonitor(path: String): ServiceMonitorWrapper {
- return loadGenericResource(path) { x: String ->
- ServiceMonitorWrapper(
- YamlParser().parse(
- path,
- HashMap<String, String>()::class.java
- )!!
- )
- }
+ private fun loadCustomResourceWrapper(path: String, context: CustomResourceDefinitionContext): CustomResourceWrapper {
+ return loadGenericResource(path) {
+ CustomResourceWrapper(
+ YamlParser().parse(
+ path,
+ HashMap<String, String>()::class.java
+ )!!,
+ context
+ )
+ }
+ }
+
+ private fun loadServiceMonitor(path: String): CustomResourceWrapper {
+ val context = K8sContextFactory().create(
+ api = "v1",
+ scope = "Namespaced",
+ group = "monitoring.coreos.com",
+ plural = "servicemonitors"
+ )
+ return loadCustomResourceWrapper(path, context)
+ }
+
+ private fun loadExecution(path: String): KubernetesResource {
+ val context = K8sContextFactory().create(
+ api = "v1",
+ scope = "Namespaced",
+ group = "theodolite.com",
+ plural = "executions"
+ )
+ return loadCustomResourceWrapper(path, context)
+ }
+
+ private fun loadBenchmark(path: String): KubernetesResource {
+ val context = K8sContextFactory().create(
+ api = "v1",
+ scope = "Namespaced",
+ group = "theodolite.com",
+ plural = "benchmarks"
+ )
+ return loadCustomResourceWrapper(path, context)
}
+
/**
* Parses a Deployment from a Deployment yaml
* @param path of the yaml file
@@ -60,6 +95,16 @@ class K8sResourceLoader(private val client: NamespacedKubernetesClient) {
return loadGenericResource(path) { x: String -> client.configMaps().load(x).get() }
}
+ /**
+ * Parses a StatefulSet from a StatefulSet yaml
+ * @param path of the yaml file
+ * @return StatefulSet from fabric8
+ */
+ private fun loadStatefulSet(path: String): KubernetesResource {
+ return loadGenericResource(path) { x: String -> client.apps().statefulSets().load(x).get() }
+
+ }
+
/**
* Generic helper function to load a resource.
* @param path of the resource
@@ -96,6 +141,9 @@ class K8sResourceLoader(private val client: NamespacedKubernetesClient) {
"Service" -> loadService(path)
"ServiceMonitor" -> loadServiceMonitor(path)
"ConfigMap" -> loadConfigmap(path)
+ "StatefulSet" -> loadStatefulSet(path)
+ "Execution" -> loadExecution(path)
+ "Benchmark" -> loadBenchmark(path)
else -> {
logger.error { "Error during loading of unspecified resource Kind" }
throw java.lang.IllegalArgumentException("error while loading resource with kind: $kind")
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
index c2b30ab7eb23d60db39778218ad9d6a4c12799a6..49131352cfe517a382ddd7aa1be09d3fbe317466 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
@@ -98,7 +98,7 @@ class CompositeStrategyTest {
val results = Results()
val benchmark = TestBenchmark()
val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
- val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0, 0,0)
+ val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0, 0, 0)
val binarySearch = BinarySearch(benchmarkExecutor)
val lowerBoundRestriction = LowerBoundRestriction(results)
val strategy =
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt
index 4ae9ce23b31204b366dce7bcf000e4114d7f3f8f..e88192dd7fe4393494a4fb76bd74d1123bd75f1d 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt
@@ -56,7 +56,7 @@ class ResourceLimitPatcherTest {
k8sResources = listOf(Pair("cpu-memory-deployment.yaml", k8sResource))
).patch(value = memValue)
- k8sResource.spec.template.spec.containers.filter { it.name == defCPU.properties["container"] !! }
+ k8sResource.spec.template.spec.containers.filter { it.name == defCPU.properties["container"]!! }
.forEach {
assertTrue(it.resources.limits["cpu"].toString() == cpuValue)
assertTrue(it.resources.limits["memory"].toString() == memValue)
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt
index 6f232961871c9d11929fc912a483e6e805cc7daf..2af6c632567bf47e150a74808ab009bd0bc0598a 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt
@@ -55,7 +55,7 @@ class ResourceRequestPatcherTest {
k8sResources = listOf(Pair("cpu-memory-deployment.yaml", k8sResource))
).patch(value = memValue)
- k8sResource.spec.template.spec.containers.filter { it.name == defCPU.properties["container"] !! }
+ k8sResource.spec.template.spec.containers.filter { it.name == defCPU.properties["container"]!! }
.forEach {
assertTrue(it.resources.requests["cpu"].toString() == cpuValue)
assertTrue(it.resources.requests["memory"].toString() == memValue)
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt
index 6ddca296acced658609fcccb307a83047238e118..913a27a1b1c1412aa0a58baf9e11fafb1c7f4bd2 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt
@@ -2,8 +2,8 @@ package theodolite
import theodolite.benchmark.Benchmark
import theodolite.benchmark.BenchmarkDeployment
-import theodolite.util.LoadDimension
import theodolite.util.ConfigurationOverride
+import theodolite.util.LoadDimension
import theodolite.util.Resource
class TestBenchmark : Benchmark {
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/BenchmarkCRDummy.kt b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/BenchmarkCRDummy.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f3fd06a16e38439a2a694b415edc4d8b332ffd4d
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/BenchmarkCRDummy.kt
@@ -0,0 +1,34 @@
+package theodolite.execution.operator
+
+import theodolite.benchmark.KubernetesBenchmark
+import theodolite.model.crd.BenchmarkCRD
+import theodolite.util.KafkaConfig
+
+class BenchmarkCRDummy(name: String) {
+
+ private val benchmark = KubernetesBenchmark()
+ private val benchmarkCR = BenchmarkCRD(benchmark)
+
+ fun getCR(): BenchmarkCRD {
+ return benchmarkCR
+ }
+
+ init {
+ val kafkaConfig = KafkaConfig()
+
+ kafkaConfig.bootstrapServer = ""
+ kafkaConfig.topics = emptyList()
+
+ benchmarkCR.spec = benchmark
+ benchmarkCR.metadata.name = name
+ benchmarkCR.kind = "Benchmark"
+ benchmarkCR.apiVersion = "v1"
+
+ benchmark.appResource = emptyList()
+ benchmark.loadGenResource = emptyList()
+ benchmark.resourceTypes = emptyList()
+ benchmark.loadTypes = emptyList()
+ benchmark.kafkaConfig = kafkaConfig
+ benchmark.name = benchmarkCR.metadata.name
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ControllerDummy.kt b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ControllerDummy.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3ecc2ef422e579b616f304ec8c4b19110941dcea
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ControllerDummy.kt
@@ -0,0 +1,86 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.NamespacedKubernetesClient
+import io.fabric8.kubernetes.client.dsl.MixedOperation
+import io.fabric8.kubernetes.client.dsl.Resource
+import io.fabric8.kubernetes.internal.KubernetesDeserializer
+import theodolite.k8s.K8sContextFactory
+import theodolite.model.crd.*
+
+private const val SCOPE = "Namespaced"
+private const val EXECUTION_SINGULAR = "execution"
+private const val EXECUTION_PLURAL = "executions"
+private const val BENCHMARK_SINGULAR = "benchmark"
+private const val BENCHMARK_PLURAL = "benchmarks"
+private const val API_VERSION = "v1"
+private const val GROUP = "theodolite.com"
+
+class ControllerDummy(val client: NamespacedKubernetesClient) {
+
+ private var controller: TheodoliteController
+ val executionContext = K8sContextFactory()
+ .create(
+ API_VERSION,
+ SCOPE,
+ GROUP,
+ EXECUTION_PLURAL
+ )
+ val benchmarkContext = K8sContextFactory()
+ .create(
+ API_VERSION,
+ SCOPE,
+ GROUP,
+ BENCHMARK_PLURAL
+ )
+
+ val executionStateHandler = ExecutionStateHandler(
+ context = executionContext,
+ client = client
+ )
+
+ fun getController(): TheodoliteController {
+ return this.controller
+ }
+
+ init {
+ KubernetesDeserializer.registerCustomKind(
+ "$GROUP/$API_VERSION",
+ EXECUTION_SINGULAR,
+ ExecutionCRD::class.java
+ )
+
+ KubernetesDeserializer.registerCustomKind(
+ "$GROUP/$API_VERSION",
+ BENCHMARK_SINGULAR,
+ BenchmarkCRD::class.java
+ )
+
+ val executionCRDClient: MixedOperation<
+ ExecutionCRD,
+ BenchmarkExecutionList,
+ DoneableExecution,
+ Resource<ExecutionCRD, DoneableExecution>> = client.customResources(
+ executionContext,
+ ExecutionCRD::class.java,
+ BenchmarkExecutionList::class.java,
+ DoneableExecution::class.java
+ )
+
+ val benchmarkCRDClient = client.customResources(
+ benchmarkContext,
+ BenchmarkCRD::class.java,
+ KubernetesBenchmarkList::class.java,
+ DoneableBenchmark::class.java
+ )
+
+ val appResource = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
+ this.controller =
+ TheodoliteController(
+ namespace = client.namespace,
+ path = appResource,
+ benchmarkCRDClient = benchmarkCRDClient,
+ executionCRDClient = executionCRDClient,
+ executionStateHandler = executionStateHandler
+ )
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ControllerTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ControllerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9174a4cc78933d4c028b2c2a73e1adb63047868f
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ControllerTest.kt
@@ -0,0 +1,138 @@
+package theodolite.execution.operator
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import io.fabric8.kubernetes.client.CustomResourceList
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer
+import io.quarkus.test.junit.QuarkusTest
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import theodolite.benchmark.BenchmarkExecution
+import theodolite.benchmark.KubernetesBenchmark
+import theodolite.model.crd.BenchmarkCRD
+import theodolite.model.crd.ExecutionCRD
+
+@QuarkusTest
+class ControllerTest {
+ private final val server = KubernetesServer(false, false)
+ lateinit var controller: TheodoliteController
+ private val gson: Gson = GsonBuilder().enableComplexMapKeySerialization().create()
+
+ private var benchmark = KubernetesBenchmark()
+ private var execution = BenchmarkExecution()
+
+ private val benchmarkResourceList = CustomResourceList<BenchmarkCRD>()
+ private val executionResourceList = CustomResourceList<ExecutionCRD>()
+
+
+ @BeforeEach
+ fun setUp() {
+ server.before()
+ this.controller = ControllerDummy(server.client).getController()
+
+ // benchmark
+ val benchmark1 = BenchmarkCRDummy(name = "Test-Benchmark")
+ val benchmark2 = BenchmarkCRDummy(name = "Test-Benchmark-123")
+ benchmarkResourceList.items = listOf(benchmark1.getCR(), benchmark2.getCR())
+
+ // execution
+ val execution1 = ExecutionCRDummy(name = "matching-execution", benchmark = "Test-Benchmark")
+ val execution2 = ExecutionCRDummy(name = "non-matching-execution", benchmark = "Test-Benchmark-456")
+ val execution3 = ExecutionCRDummy(name = "second-matching-execution", benchmark = "Test-Benchmark")
+ executionResourceList.items = listOf(execution1.getCR(), execution2.getCR(), execution3.getCR())
+
+ this.benchmark = benchmark1.getCR().spec
+ this.execution = execution1.getCR().spec
+
+ server
+ .expect()
+ .get()
+ .withPath("/apis/theodolite.com/v1/namespaces/test/benchmarks")
+ .andReturn(200, benchmarkResourceList)
+ .always()
+
+ server
+ .expect()
+ .get()
+ .withPath("/apis/theodolite.com/v1/namespaces/test/executions")
+ .andReturn(200, executionResourceList)
+ .always()
+ }
+
+ @AfterEach
+ fun tearDown() {
+ server.after()
+ }
+
+ @Test
+ fun getBenchmarksTest() {
+ val method = controller
+ .javaClass
+ .getDeclaredMethod("getBenchmarks")
+ method.isAccessible = true
+
+ val result = method.invoke(controller) as List<KubernetesBenchmark>
+
+ assertEquals(2, result.size)
+ assertEquals(
+ gson.toJson(benchmark),
+ gson.toJson(result.firstOrNull())
+ )
+ }
+
+ @Test
+ fun getNextExecution() {
+ val method = controller
+ .javaClass
+ .getDeclaredMethod("getNextExecution")
+ method.isAccessible = true
+
+ val result = method.invoke(controller) as BenchmarkExecution?
+
+ assertEquals(
+ gson.toJson(this.execution),
+ gson.toJson(result)
+ )
+ }
+
+ @Test
+ fun setAdditionalLabelsTest() {
+ val method = controller
+ .javaClass
+ .getDeclaredMethod(
+ "setAdditionalLabels",
+ String::class.java,
+ String::class.java,
+ List::class.java,
+ BenchmarkExecution::class.java
+ )
+ method.isAccessible = true
+
+ this.benchmark.appResource = listOf("test-resource.yaml")
+
+ method.invoke(
+ controller,
+ "test-value",
+ "test-name",
+ this.benchmark.appResource,
+ this.execution
+ ) as BenchmarkExecution?
+
+ assertEquals(
+ "test-name",
+ this.execution
+ .configOverrides.firstOrNull()
+ ?.patcher
+ ?.properties
+ ?.get("variableName")
+ )
+ assertEquals(
+ "test-value",
+ this.execution
+ .configOverrides.firstOrNull()
+ ?.value
+ )
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ExecutionCRDummy.kt b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ExecutionCRDummy.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2589319299cfa29f95216033ddc806d002f38663
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ExecutionCRDummy.kt
@@ -0,0 +1,52 @@
+package theodolite.execution.operator
+
+import theodolite.benchmark.BenchmarkExecution
+import theodolite.model.crd.ExecutionCRD
+import theodolite.model.crd.ExecutionStatus
+import theodolite.model.crd.States
+
+class ExecutionCRDummy(name: String, benchmark: String) {
+
+ private val execution = BenchmarkExecution()
+ private val executionState = ExecutionStatus()
+ private val executionCR = ExecutionCRD(execution, executionState)
+
+ fun getCR(): ExecutionCRD {
+ return this.executionCR
+ }
+
+ init {
+ // configure metadata
+ executionCR.spec = execution
+ executionCR.metadata.name = name
+ executionCR.kind = "Execution"
+ executionCR.apiVersion = "v1"
+
+ // configure execution
+ val loadType = BenchmarkExecution.LoadDefinition()
+ loadType.loadType = ""
+ loadType.loadValues = emptyList()
+
+ val resourceDef = BenchmarkExecution.ResourceDefinition()
+ resourceDef.resourceType = ""
+ resourceDef.resourceValues = emptyList()
+
+ val exec = BenchmarkExecution.Execution()
+ exec.afterTeardownDelay = 0
+ exec.duration = 0
+ exec.loadGenerationDelay = 0
+ exec.repetitions = 1
+ exec.restrictions = emptyList()
+ exec.strategy = ""
+
+ execution.benchmark = benchmark
+ execution.load = loadType
+ execution.resources = resourceDef
+ execution.slos = emptyList()
+ execution.execution = exec
+ execution.configOverrides = mutableListOf()
+ execution.name = executionCR.metadata.name
+
+ executionState.executionState = States.PENDING.value
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ExecutionEventHandlerTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ExecutionEventHandlerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9c3468eaa4df7573a1d909222d6faa7449fd7251
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/ExecutionEventHandlerTest.kt
@@ -0,0 +1,222 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.api.model.KubernetesResource
+import io.fabric8.kubernetes.client.informers.SharedInformerFactory
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer
+import io.quarkus.test.junit.QuarkusTest
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import theodolite.k8s.K8sManager
+import theodolite.k8s.K8sResourceLoader
+import theodolite.model.crd.BenchmarkExecutionList
+import theodolite.model.crd.ExecutionCRD
+import theodolite.model.crd.States
+import java.lang.Thread.sleep
+
+
+private const val RESYNC_PERIOD = 1000 * 1000.toLong()
+
+
+@QuarkusTest
+class ExecutionEventHandlerTest {
+ private final val server = KubernetesServer(false, true)
+ private val testResourcePath = "./src/test/resources/k8s-resource-files/"
+ private final val executionName = "example-execution"
+ lateinit var factory: SharedInformerFactory
+ lateinit var executionVersion1: KubernetesResource
+ lateinit var executionVersion2: KubernetesResource
+ lateinit var stateHandler: ExecutionStateHandler
+ lateinit var manager: K8sManager
+
+ @BeforeEach
+ fun setUp() {
+ server.before()
+ val controllerDummy = ControllerDummy(server.client)
+
+ this.factory = server.client.informers()
+ val informerExecution = factory
+ .sharedIndexInformerForCustomResource(
+ controllerDummy.executionContext,
+ ExecutionCRD::class.java,
+ BenchmarkExecutionList::class.java,
+ RESYNC_PERIOD
+ )
+
+ informerExecution.addEventHandler(
+ ExecutionHandler(
+ controller = controllerDummy.getController(),
+ stateHandler = controllerDummy.executionStateHandler
+ )
+ )
+
+ this.executionVersion1 = K8sResourceLoader(server.client)
+ .loadK8sResource("Execution", testResourcePath + "test-execution.yaml")
+
+ this.executionVersion2 = K8sResourceLoader(server.client)
+ .loadK8sResource("Execution", testResourcePath + "test-execution-update.yaml")
+
+ this.stateHandler = ControllerDummy(server.client).executionStateHandler
+
+ this.manager = K8sManager((server.client))
+ }
+
+ @AfterEach
+ fun tearDown() {
+ server.after()
+ factory.stopAllRegisteredInformers()
+ }
+
+ @Test
+ @DisplayName("Test onAdd method for executions without execution state")
+ fun testWithoutState() {
+ manager.deploy(executionVersion1)
+ factory.startAllRegisteredInformers()
+ sleep(500)
+ assertEquals(
+ States.PENDING,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+ }
+
+ @Test
+ @DisplayName("Test onAdd method for executions with execution state `RUNNING`")
+ fun testWithStateIsRunning() {
+ manager.deploy(executionVersion1)
+ stateHandler
+ .setExecutionState(
+ resourceName = executionName,
+ status = States.RUNNING
+ )
+ factory.startAllRegisteredInformers()
+ sleep(500)
+ assertEquals(
+ States.RESTART,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+ }
+
+ @Test
+ @DisplayName("Test onUpdate method for execution with execution state `PENDING`")
+ fun testOnUpdatePending() {
+ manager.deploy(executionVersion1)
+
+ factory.startAllRegisteredInformers()
+ sleep(500)
+
+ assertEquals(
+ States.PENDING,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+
+ manager.deploy(executionVersion2)
+ assertEquals(
+ States.PENDING,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+
+ }
+
+ @Test
+ @DisplayName("Test onUpdate method for execution with execution state `FINISHED`")
+ fun testOnUpdateFinished() {
+ manager.deploy(executionVersion1)
+ factory.startAllRegisteredInformers()
+ sleep(500)
+
+ stateHandler.setExecutionState(
+ resourceName = executionName,
+ status = States.FINISHED
+ )
+
+ manager.deploy(executionVersion2)
+ sleep(500)
+
+ assertEquals(
+ States.PENDING,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+ }
+
+ @Test
+ @DisplayName("Test onUpdate method for execution with execution state `FAILURE`")
+ fun testOnUpdateFailure() {
+ manager.deploy(executionVersion1)
+ factory.startAllRegisteredInformers()
+ sleep(500)
+
+ stateHandler.setExecutionState(
+ resourceName = executionName,
+ status = States.FAILURE
+ )
+
+ manager.deploy(executionVersion2)
+ sleep(500)
+
+ assertEquals(
+ States.PENDING,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+ }
+
+
+ @Test
+ @DisplayName("Test onUpdate method for execution with execution state `RUNNING`")
+ fun testOnUpdateRunning() {
+ manager.deploy(executionVersion1)
+ factory.startAllRegisteredInformers()
+ sleep(500)
+
+ stateHandler.setExecutionState(
+ resourceName = executionName,
+ status = States.RUNNING
+ )
+
+ manager.deploy(executionVersion2)
+ sleep(500)
+
+ assertEquals(
+ States.RESTART,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+ }
+
+ @Test
+ @DisplayName("Test onUpdate method for execution with execution state `RESTART`")
+ fun testOnUpdateRestart() {
+ manager.deploy(executionVersion1)
+ factory.startAllRegisteredInformers()
+ sleep(500)
+
+ stateHandler.setExecutionState(
+ resourceName = executionName,
+ status = States.RESTART
+ )
+
+ manager.deploy(executionVersion2)
+ sleep(500)
+
+ assertEquals(
+ States.RESTART,
+ stateHandler.getExecutionState(
+ resourceName = executionName
+ )
+ )
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/StateHandlerTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/StateHandlerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1b92b1e2938df49be2a3a9950d8eb911a7963a40
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/execution/operator/StateHandlerTest.kt
@@ -0,0 +1,58 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import theodolite.k8s.K8sContextFactory
+import theodolite.k8s.K8sManager
+import theodolite.k8s.K8sResourceLoader
+import theodolite.model.crd.States
+import java.time.Duration
+
+class StateHandlerTest {
+ private val testResourcePath = "./src/test/resources/k8s-resource-files/"
+ private val server = KubernetesServer(false, true)
+ private val context = K8sContextFactory().create(
+ api = "v1",
+ scope = "Namespaced",
+ group = "theodolite.com",
+ plural = "executions"
+ )
+
+
+ @BeforeEach
+ fun setUp() {
+ server.before()
+ val executionResource = K8sResourceLoader(server.client)
+ .loadK8sResource("Execution", testResourcePath + "test-execution.yaml")
+
+ K8sManager(server.client).deploy(executionResource)
+ }
+
+ @AfterEach
+ fun tearDown() {
+ server.after()
+ }
+
+ @Test
+ @DisplayName("Test set and get of the execution state")
+ fun executionStatusTest() {
+ val handler = ExecutionStateHandler(client = server.client, context = context)
+
+ assertTrue(handler.setExecutionState("example-execution", States.INTERRUPTED))
+ assertEquals(States.INTERRUPTED, handler.getExecutionState("example-execution"))
+ }
+
+ @Test
+ @DisplayName("Test set and get of the duration state")
+ fun durationStatusTest() {
+ val handler = ExecutionStateHandler(client = server.client, context = context)
+
+ assertTrue(handler.setDurationState("example-execution", Duration.ofMillis(100)))
+ assertEquals("0s", handler.getDurationState("example-execution"))
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/k8s/K8sManagerTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/k8s/K8sManagerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..931457b0fc65984c35516dca57dbe52e94184064
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/k8s/K8sManagerTest.kt
@@ -0,0 +1,155 @@
+package theodolite.k8s
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import io.fabric8.kubernetes.api.model.*
+import io.fabric8.kubernetes.api.model.apps.Deployment
+import io.fabric8.kubernetes.api.model.apps.DeploymentBuilder
+import io.fabric8.kubernetes.api.model.apps.StatefulSet
+import io.fabric8.kubernetes.api.model.apps.StatefulSetBuilder
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer
+import io.quarkus.test.junit.QuarkusTest
+import mu.KotlinLogging
+import org.json.JSONObject
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+
+private val logger = KotlinLogging.logger {}
+
+@QuarkusTest
+@JsonIgnoreProperties(ignoreUnknown = true)
+class K8sManagerTest {
+ @JsonIgnoreProperties(ignoreUnknown = true)
+ private final val server = KubernetesServer(false, true)
+ private final val testResourcePath = "./src/test/resources/k8s-resource-files/"
+
+ private final val resourceName = "test-resource"
+ private final val metadata: ObjectMeta = ObjectMetaBuilder().withName(resourceName).build()
+
+
+ val defaultDeployment: Deployment = DeploymentBuilder()
+ .withMetadata(metadata)
+ .withNewSpec()
+ .editOrNewSelector()
+ .withMatchLabels(mapOf("app" to "test"))
+ .endSelector()
+ .endSpec()
+ .build()
+
+ val defaultStatefulSet: StatefulSet = StatefulSetBuilder()
+ .withMetadata(metadata)
+ .withNewSpec()
+ .editOrNewSelector()
+ .withMatchLabels(mapOf("app" to "test"))
+ .endSelector()
+ .endSpec()
+ .build()
+
+ val defaultService: Service = ServiceBuilder()
+ .withMetadata(metadata)
+ .build()
+
+ val defaultConfigMap: ConfigMap = ConfigMapBuilder()
+ .withMetadata(metadata)
+ .build()
+
+ @BeforeEach
+ fun setUp() {
+ server.before()
+
+ }
+
+ @AfterEach
+ fun tearDown() {
+ server.after()
+
+ }
+
+ @Test
+ @DisplayName("Test handling of Deployments")
+ fun handleDeploymentTest() {
+ val manager = K8sManager(server.client)
+
+ manager.deploy(defaultDeployment)
+ assertEquals(1, server.client.apps().deployments().list().items.size)
+ assertEquals(resourceName, server.client.apps().deployments().list().items.first().metadata.name)
+
+ manager.remove(defaultDeployment)
+ assertEquals(0, server.client.apps().deployments().list().items.size)
+ }
+
+ @Test
+ @DisplayName("Test handling of StatefulSets")
+ fun handleStatefulSetTest() {
+ val manager = K8sManager(server.client)
+
+ manager.deploy(defaultStatefulSet)
+ assertEquals(1, server.client.apps().statefulSets().list().items.size)
+ assertEquals(resourceName, server.client.apps().statefulSets().list().items.first().metadata.name)
+
+ manager.remove(defaultStatefulSet)
+ assertEquals(0, server.client.apps().statefulSets().list().items.size)
+ }
+
+ @Test
+ @DisplayName("Test handling of Services")
+ fun handleServiceTest() {
+ val manager = K8sManager(server.client)
+
+ manager.deploy(defaultService)
+ assertEquals(1, server.client.services().list().items.size)
+ assertEquals(resourceName, server.client.services().list().items.first().metadata.name)
+
+ manager.remove(defaultService)
+ assertEquals(0, server.client.services().list().items.size)
+ }
+
+
+ @Test
+ @DisplayName("Test handling of ConfigMaps")
+ fun handleConfigMapTest() {
+ val manager = K8sManager(server.client)
+
+ manager.deploy(defaultConfigMap)
+ assertEquals(1, server.client.configMaps().list().items.size)
+ assertEquals(resourceName, server.client.configMaps().list().items.first().metadata.name)
+
+ manager.remove(defaultConfigMap)
+ assertEquals(0, server.client.configMaps().list().items.size)
+ }
+
+ @Test
+ @DisplayName("Test handling of custom resources")
+ fun handleCustomResourcesTest() {
+ val manager = K8sManager(server.client)
+ val servicemonitor = K8sResourceLoader(server.client)
+ .loadK8sResource("ServiceMonitor", testResourcePath + "test-service-monitor.yaml")
+
+ val serviceMonitorContext = K8sContextFactory().create(
+ api = "v1",
+ scope = "Namespaced",
+ group = "monitoring.coreos.com",
+ plural = "servicemonitors"
+ )
+ manager.deploy(servicemonitor)
+
+ var serviceMonitors = JSONObject(server.client.customResource(serviceMonitorContext).list())
+ .getJSONArray("items")
+
+ assertEquals(1, serviceMonitors.length())
+ assertEquals(
+ "test-service-monitor",
+ serviceMonitors.getJSONObject(0).getJSONObject("metadata").getString("name")
+ )
+
+ manager.remove(servicemonitor)
+
+ serviceMonitors = JSONObject(server.client.customResource(serviceMonitorContext).list())
+ .getJSONArray("items")
+
+ assertEquals(0, serviceMonitors.length())
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/k8s/K8sResourceLoaderTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/k8s/K8sResourceLoaderTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5cb6f0c4cf09daeaa95a805ae965f5b592fd9647
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/k8s/K8sResourceLoaderTest.kt
@@ -0,0 +1,110 @@
+package theodolite.k8s
+
+import io.fabric8.kubernetes.api.model.ConfigMap
+import io.fabric8.kubernetes.api.model.Service
+import io.fabric8.kubernetes.api.model.apps.Deployment
+import io.fabric8.kubernetes.api.model.apps.StatefulSet
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer
+import io.quarkus.test.junit.QuarkusTest
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+@QuarkusTest
+class K8sResourceLoaderTest {
+ private final val server = KubernetesServer(false, true)
+ private final val testResourcePath = "./src/test/resources/k8s-resource-files/"
+
+ @BeforeEach
+ fun setUp() {
+ server.before()
+ }
+
+ @AfterEach
+ fun tearDown() {
+ server.after()
+ }
+
+ @Test
+ @DisplayName("Test loading of Deployments")
+ fun loadDeploymentTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("Deployment", testResourcePath + "test-deployment.yaml")
+
+ assertTrue(resource is Deployment)
+ assertTrue(resource.toString().contains("name=test-deployment"))
+ }
+
+ @Test
+ @DisplayName("Test loading of StatefulSet")
+ fun loadStatefulSetTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("StatefulSet", testResourcePath + "test-statefulset.yaml")
+
+ assertTrue(resource is StatefulSet)
+ assertTrue(resource.toString().contains("name=test-statefulset"))
+ }
+
+ @Test
+ @DisplayName("Test loading of Service")
+ fun loadServiceTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("Service", testResourcePath + "test-service.yaml")
+
+ assertTrue(resource is Service)
+ assertTrue(resource.toString().contains("name=test-service"))
+ }
+
+ @Test
+ @DisplayName("Test loading of ConfigMap")
+ fun loadConfigMapTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("ConfigMap", testResourcePath + "test-configmap.yaml")
+
+ assertTrue(resource is ConfigMap)
+ assertTrue(resource.toString().contains("name=test-configmap"))
+ }
+
+ @Test
+ @DisplayName("Test loading of ServiceMonitors")
+ fun loadServiceMonitorTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("ServiceMonitor", testResourcePath + "test-service-monitor.yaml")
+
+ assertTrue(resource is CustomResourceWrapper)
+ if (resource is CustomResourceWrapper) {
+ assertEquals("test-service-monitor", resource.getName())
+
+ }
+ }
+
+ @Test
+ @DisplayName("Test loading of ServiceMonitors")
+ fun loadExecutionTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("Execution", testResourcePath + "test-execution.yaml")
+
+ assertTrue(resource is CustomResourceWrapper)
+ if (resource is CustomResourceWrapper) {
+ assertEquals("example-execution", resource.getName())
+
+ }
+ }
+
+ @Test
+ @DisplayName("Test loading of ServiceMonitors")
+ fun loadBenchmarkTest() {
+ val loader = K8sResourceLoader(server.client)
+ val resource = loader.loadK8sResource("Benchmark", testResourcePath + "test-benchmark.yaml")
+
+ assertTrue(resource is CustomResourceWrapper)
+ if (resource is CustomResourceWrapper) {
+ assertEquals("example-benchmark", resource.getName())
+
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt
index 6984c3935da3d26f95565b758547a98e0eeb155f..6b8aa1d567fd2c93c1301fe3f953273e0f5d5420 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt
@@ -14,6 +14,7 @@ import org.junitpioneer.jupiter.SetEnvironmentVariable
const val FOLDER_URL = "Test-Folder"
+
@QuarkusTest
internal class IOHandlerTest {
@@ -28,10 +29,11 @@ internal class IOHandlerTest {
IOHandler().writeStringToTextFile(
fileURL = "${folder.absolutePath}/test-file.txt",
- data = testContent)
+ data = testContent
+ )
assertEquals(
- testContent,
+ testContent,
IOHandler().readFileAsString("${folder.absolutePath}/test-file.txt")
)
}
@@ -42,18 +44,20 @@ internal class IOHandlerTest {
val folder = temporaryFolder.newFolder(FOLDER_URL)
val testContent = listOf(
- listOf("apples","red"),
- listOf("bananas","yellow"),
- listOf("avocado","brown"))
+ listOf("apples", "red"),
+ listOf("bananas", "yellow"),
+ listOf("avocado", "brown")
+ )
val columns = listOf("Fruit", "Color")
IOHandler().writeToCSVFile(
fileURL = "${folder.absolutePath}/test-file",
data = testContent,
- columns = columns)
+ columns = columns
+ )
var expected = "Fruit,Color\n"
- testContent.forEach { expected += it[0] + "," + it[1] + "\n" }
+ testContent.forEach { expected += it[0] + "," + it[1] + "\n" }
assertEquals(
expected.trim(),
@@ -68,8 +72,9 @@ internal class IOHandlerTest {
val testContent = Resource(0, emptyList())
IOHandler().writeToJSONFile(
- fileURL = "${folder.absolutePath}/test-file.json",
- objectToSave = testContent)
+ fileURL = "${folder.absolutePath}/test-file.json",
+ objectToSave = testContent
+ )
val expected = GsonBuilder().enableComplexMapKeySerialization().setPrettyPrinting().create().toJson(testContent)
@@ -87,7 +92,7 @@ internal class IOHandlerTest {
ClearEnvironmentVariable(key = "CREATE_RESULTS_FOLDER")
)
fun testGetResultFolderURL_emptyEnvironmentVars() {
- assertEquals("",IOHandler().getResultFolderURL())
+ assertEquals("", IOHandler().getResultFolderURL())
}
@@ -109,10 +114,10 @@ internal class IOHandlerTest {
var exceptionWasThrown = false
try {
IOHandler().getResultFolderURL()
- } catch (e: Exception){
- exceptionWasThrown = true
- assertThat(e.toString(), containsString("Result folder not found"));
- }
+ } catch (e: Exception) {
+ exceptionWasThrown = true
+ assertThat(e.toString(), containsString("Result folder not found"))
+ }
assertTrue(exceptionWasThrown)
}
@@ -122,13 +127,13 @@ internal class IOHandlerTest {
SetEnvironmentVariable(key = "CREATE_RESULTS_FOLDER", value = "true")
)
fun testGetResultFolderURL_CreateFolderIfNotExist() {
- assertEquals("$FOLDER_URL/", IOHandler().getResultFolderURL())
+ assertEquals("$FOLDER_URL/", IOHandler().getResultFolderURL())
}
@Test()
- @ClearEnvironmentVariable(key = "RESULTS_FOLDER" )
+ @ClearEnvironmentVariable(key = "RESULTS_FOLDER")
@SetEnvironmentVariable(key = "CREATE_RESULTS_FOLDER", value = "true")
fun testGetResultFolderURL_CreateFolderButNoFolderGiven() {
- assertEquals("", IOHandler().getResultFolderURL())
+ assertEquals("", IOHandler().getResultFolderURL())
}
}
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-benchmark.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-benchmark.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e690aa56d74d695b0b81469023ccf82d0046cf45
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-benchmark.yaml
@@ -0,0 +1,38 @@
+apiVersion: theodolite.com/v1
+kind: benchmark
+metadata:
+ name: example-benchmark
+spec:
+ appResource:
+ - "uc1-kstreams-deployment.yaml"
+ - "aggregation-service.yaml"
+ - "jmx-configmap.yaml"
+ - "uc1-service-monitor.yaml"
+ loadGenResource:
+ - "uc1-load-generator-deployment.yaml"
+ - "uc1-load-generator-service.yaml"
+ resourceTypes:
+ - typeName: "Instances"
+ patchers:
+ - type: "ReplicaPatcher"
+ resource: "uc1-kstreams-deployment.yaml"
+ loadTypes:
+ - typeName: "NumSensors"
+ patchers:
+ - type: "EnvVarPatcher"
+ resource: "uc1-load-generator-deployment.yaml"
+ properties:
+ variableName: "NUM_SENSORS"
+ container: "workload-generator"
+ - type: "NumSensorsLoadGeneratorReplicaPatcher"
+ resource: "uc1-load-generator-deployment.yaml"
+ properties:
+ loadGenMaxRecords: "15000"
+ kafkaConfig:
+ bootstrapServer: "theodolite-cp-kafka:9092"
+ topics:
+ - name: "input"
+ numPartitions: 40
+ replicationFactor: 1
+ - name: "theodolite-.*"
+ removeOnly: True
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-configmap.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-configmap.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..dce11c991749e538d856e664539e136e19a8ce6b
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-configmap.yaml
@@ -0,0 +1,6 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+ name: test-configmap
+data:
+ test: test
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-deployment.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-deployment.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e9c4bda12ce781dc85307ec393f821a5df04599e
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-deployment.yaml
@@ -0,0 +1,17 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ selector:
+ matchLabels:
+ app: titan-ccp-aggregation
+ template:
+ metadata:
+ labels:
+ app: titan-ccp-aggregation
+ spec:
+ containers:
+ - name: uc-application
+ image: ghcr.io/cau-se/theodolite-uc1-kstreams-app:latest
+
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-execution-update.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-execution-update.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4ef4fdc007816bb492fbd90d6ddc516a2332cd5e
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-execution-update.yaml
@@ -0,0 +1,28 @@
+apiVersion: theodolite.com/v1
+kind: execution
+metadata:
+ name: example-execution
+spec:
+ name: test
+ benchmark: "uc1-kstreams-update"
+ load:
+ loadType: "NumSensors"
+ loadValues: [25000, 50000, 75000, 100000, 125000, 150000]
+ resources:
+ resourceType: "Instances"
+ resourceValues: [1, 2, 3, 4, 5]
+ slos:
+ - sloType: "lag trend"
+ threshold: 2000
+ prometheusUrl: "http://prometheus-operated:9090"
+ externalSloUrl: "http://localhost:80/evaluate-slope"
+ offset: 0
+ warmup: 60 # in seconds
+ execution:
+ strategy: "LinearSearch"
+ duration: 300 # in seconds
+ repetitions: 1
+ loadGenerationDelay: 30 # in seconds
+ restrictions:
+ - "LowerBound"
+ configOverrides: []
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-execution.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-execution.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4d6ade6ae32b064fd45b3fa508a936645538a543
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-execution.yaml
@@ -0,0 +1,28 @@
+apiVersion: theodolite.com/v1
+kind: execution
+metadata:
+ name: example-execution
+spec:
+ name: test
+ benchmark: "uc1-kstreams"
+ load:
+ loadType: "NumSensors"
+ loadValues: [25000, 50000, 75000, 100000, 125000, 150000]
+ resources:
+ resourceType: "Instances"
+ resourceValues: [1, 2, 3, 4, 5]
+ slos:
+ - sloType: "lag trend"
+ threshold: 2000
+ prometheusUrl: "http://prometheus-operated:9090"
+ externalSloUrl: "http://localhost:80/evaluate-slope"
+ offset: 0
+ warmup: 60 # in seconds
+ execution:
+ strategy: "LinearSearch"
+ duration: 300 # in seconds
+ repetitions: 1
+ loadGenerationDelay: 30 # in seconds
+ restrictions:
+ - "LowerBound"
+ configOverrides: []
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-service-monitor.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-service-monitor.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e8a0e52e15245e790adf2cbf84edb517754267be
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-service-monitor.yaml
@@ -0,0 +1,7 @@
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+ labels:
+ app: titan-ccp-aggregation
+ appScope: titan-ccp
+ name: test-service-monitor
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-service.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-service.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..471b6db83525b1afbe8cdac38c42399ecc33ef57
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-service.yaml
@@ -0,0 +1,9 @@
+apiVersion: v1
+kind: Service
+metadata:
+ name: test-service
+ labels:
+ app: titan-ccp-aggregation
+spec:
+ selector:
+ app: titan-ccp-aggregation
\ No newline at end of file
diff --git a/theodolite-quarkus/src/test/resources/k8s-resource-files/test-statefulset.yaml b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-statefulset.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6a8810e9ee156ae1b055c1bef6ed4b29d1c41668
--- /dev/null
+++ b/theodolite-quarkus/src/test/resources/k8s-resource-files/test-statefulset.yaml
@@ -0,0 +1,16 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+ name: test-statefulset
+spec:
+ selector:
+ matchLabels:
+ app: nginx
+ template:
+ metadata:
+ labels:
+ app: nginx
+ spec:
+ containers:
+ - name: nginx
+ image: k8s.gcr.io/nginx-slim:0.8