test: Add test cases with init containers to ResourceRequirementsSanitizerTest

Signed-off-by: David Sondermann <[email protected]>

Author: Donnerbart

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/dependent/kubernetes/ResourceRequirementsSanitizerTest.java

@@ -9,6 +9,7 @@
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.fabric8.kubernetes.api.model.PodTemplateSpecBuilder;
 import io.fabric8.kubernetes.api.model.Quantity;
+import io.fabric8.kubernetes.api.model.apps.StatefulSet;
 import io.fabric8.kubernetes.api.model.apps.StatefulSetBuilder;
 import io.fabric8.kubernetes.client.KubernetesClient;
 import io.fabric8.kubernetes.client.utils.KubernetesSerialization;
@@ -19,6 +20,11 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verifyNoInteractions;
 
+/**
+ * Tests the {@link ResourceRequirementsSanitizer} with combinations of matching and mismatching K8s
+ * resources, using a mix of containers and init containers, as well as resource requests and
+ * limits.
+ */
 class ResourceRequirementsSanitizerTest {
 
   private final Map<String, Object> actualMap = mock();
@@ -90,110 +96,128 @@ void testSanitizeResourceRequirements_whenResourceIsNull_doNothing() {
 
   @Test
   void testSanitizeResourceRequirements_whenResourceSizeMismatch_doNothing() {
-    final var actualMap = sanitizeRequestsAndLimits(
+    final var actualMap = sanitizeRequestsAndLimits(ContainerType.CONTAINER,
         Map.of("cpu", new Quantity("2")),
         Map.of(),
         Map.of("cpu", new Quantity("4")),
         Map.of("cpu", new Quantity("4"), "memory", new Quantity("4Gi")));
-    assertResources(actualMap, "requests")
+    assertContainerResources(actualMap, "requests")
         .hasSize(1)
         .containsEntry("cpu", "2");
-    assertResources(actualMap, "limits")
+    assertContainerResources(actualMap, "limits")
         .hasSize(1)
         .containsEntry("cpu", "4");
   }
 
   @Test
   void testSanitizeResourceRequirements_whenResourceKeyMismatch_doNothing() {
-    final var actualMap = sanitizeRequestsAndLimits(
+    final var actualMap = sanitizeRequestsAndLimits(ContainerType.INIT_CONTAINER,
         Map.of("cpu", new Quantity("2")),
         Map.of("memory", new Quantity("4Gi")),
         Map.of(),
         Map.of());
-    assertResources(actualMap, "requests")
+    assertInitContainerResources(actualMap, "requests")
         .hasSize(1)
         .containsEntry("cpu", "2");
-    assertResources(actualMap, "limits").isNull();
+    assertInitContainerResources(actualMap, "limits").isNull();
   }
 
   @Test
   void testSanitizeResourceRequirements_whenResourcesHaveSameAmountAndFormat_doNothing() {
-    final var actualMap = sanitizeRequestsAndLimits(
+    final var actualMap = sanitizeRequestsAndLimits(ContainerType.CONTAINER,
         Map.of("memory", new Quantity("4Gi")),
         Map.of("memory", new Quantity("4Gi")),
         Map.of("cpu", new Quantity("2")),
         Map.of("cpu", new Quantity("2")));
-    assertResources(actualMap, "requests")
+    assertContainerResources(actualMap, "requests")
         .hasSize(1)
         .containsEntry("memory", "4Gi");
-    assertResources(actualMap, "limits")
+    assertContainerResources(actualMap, "limits")
         .hasSize(1)
         .containsEntry("cpu", "2");
   }
 
   @Test
   void testSanitizeResourceRequirements_whenResourcesHaveNumericalAmountMismatch_doNothing() {
-    final var actualMap = sanitizeRequestsAndLimits(
+    final var actualMap = sanitizeRequestsAndLimits(ContainerType.INIT_CONTAINER,
         Map.of("cpu", new Quantity("2"), "memory", new Quantity("4Gi")),
         Map.of("cpu", new Quantity("4"), "memory", new Quantity("4Ti")),
         Map.of("cpu", new Quantity("2")),
         Map.of("cpu", new Quantity("4000m")));
-    assertResources(actualMap, "requests")
+    assertInitContainerResources(actualMap, "requests")
         .hasSize(2)
         .containsEntry("cpu", "2")
         .containsEntry("memory", "4Gi");
-    assertResources(actualMap, "limits")
+    assertInitContainerResources(actualMap, "limits")
         .hasSize(1)
         .containsEntry("cpu", "2");
   }
 
   @Test
   void testSanitizeResourceRequirements_whenResourcesHaveAmountAndFormatMismatchWithSameNumericalAmount_thenSanitizeActualMap() {
-    final var actualMap = sanitizeRequestsAndLimits(
+    final var actualMap = sanitizeRequestsAndLimits(ContainerType.CONTAINER,
         Map.of("cpu", new Quantity("2"), "memory", new Quantity("4Gi")),
         Map.of("cpu", new Quantity("2000m"), "memory", new Quantity("4096Mi")),
         Map.of("cpu", new Quantity("4")),
         Map.of("cpu", new Quantity("4000m")));
-    assertResources(actualMap, "requests")
+    assertContainerResources(actualMap, "requests")
         .hasSize(2)
         .containsEntry("cpu", "2000m")
         .containsEntry("memory", "4096Mi");
-    assertResources(actualMap, "limits")
+    assertContainerResources(actualMap, "limits")
         .hasSize(1)
         .containsEntry("cpu", "4000m");
   }
 
   @SuppressWarnings("unchecked")
-  private Map<String, Object> sanitizeRequestsAndLimits(
+  private Map<String, Object> sanitizeRequestsAndLimits(final ContainerType type,
       final Map<String, Quantity> actualRequests, final Map<String, Quantity> desiredRequests,
       final Map<String, Quantity> actualLimits, final Map<String, Quantity> desiredLimits) {
-    final var actual = new StatefulSetBuilder().withNewSpec().withNewTemplate().withNewSpec()
-        .addNewContainer()
-        .withName("test")
-        .withNewResources()
-        .withRequests(actualRequests).withLimits(actualLimits)
-        .endResources()
-        .endContainer()
-        .endSpec().endTemplate().endSpec().build();
-    final var desired = new StatefulSetBuilder().withNewSpec().withNewTemplate().withNewSpec()
-        .addNewContainer()
-        .withName("test")
-        .withNewResources()
-        .withRequests(desiredRequests).withLimits(desiredLimits)
-        .endResources()
-        .endContainer()
-        .endSpec().endTemplate().endSpec().build();
-
+    final var actual = createStatefulSet(type, actualRequests, actualLimits);
+    final var desired = createStatefulSet(type, desiredRequests, desiredLimits);
     final var actualMap = serialization.convertValue(actual, Map.class);
     sanitizeResourceRequirements(actualMap,
         actual.getSpec().getTemplate(),
         desired.getSpec().getTemplate());
     return actualMap;
   }
 
-  private static MapAssert<String, Object> assertResources(final Map<String, Object> actualMap,
-      final String resourceName) {
+  private enum ContainerType {
+    CONTAINER, INIT_CONTAINER,
+  }
+
+  private static StatefulSet createStatefulSet(final ContainerType type,
+      final Map<String, Quantity> requests, final Map<String, Quantity> limits) {
+    var builder = new StatefulSetBuilder().withNewSpec().withNewTemplate().withNewSpec();
+    if (type == ContainerType.CONTAINER) {
+      builder = builder.addNewContainer()
+          .withName("test")
+          .withNewResources()
+          .withRequests(requests)
+          .withLimits(limits)
+          .endResources()
+          .endContainer();
+    } else {
+      builder = builder.addNewInitContainer()
+          .withName("test")
+          .withNewResources()
+          .withRequests(requests)
+          .withLimits(limits)
+          .endResources()
+          .endInitContainer();
+    }
+    return builder.endSpec().endTemplate().endSpec().build();
+  }
+
+  private static MapAssert<String, Object> assertContainerResources(
+      final Map<String, Object> actualMap, final String resourceName) {
     return assertThat(GenericKubernetesResource.<Map<String, Object>>get(actualMap,
         "spec", "template", "spec", "containers", 0, "resources", resourceName));
   }
+
+  private static MapAssert<String, Object> assertInitContainerResources(
+      final Map<String, Object> actualMap, final String resourceName) {
+    return assertThat(GenericKubernetesResource.<Map<String, Object>>get(actualMap,
+        "spec", "template", "spec", "initContainers", 0, "resources", resourceName));
+  }
 }