From 0746fbe0f748994f98a54c76db98cabef0389fd3 Mon Sep 17 00:00:00 2001
From: OZGCloud <ozgcloud@mgm-tp.com>
Date: Thu, 12 Dec 2024 14:19:31 +0100
Subject: [PATCH] update junittests
---
...gCloudElsterTransferUserRemoteService.java | 2 +-
.../OzgCloudElsterTransferUserService.java | 6 +-
...udElsterTransferConfigMapUserListTest.java | 3 +-
...CloudElsterTransferUserReconcilerTest.java | 12 +-
...udElsterTransferUserRemoteServiceTest.java | 221 +++-
...OzgCloudElsterTransferUserServiceTest.java | 1022 +++++++++--------
6 files changed, 744 insertions(+), 522 deletions(-)
diff --git a/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteService.java b/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteService.java
index 2e830ff..0b7533e 100644
--- a/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteService.java
+++ b/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteService.java
@@ -67,7 +67,7 @@ class OzgCloudElsterTransferUserRemoteService {
public void updateConfigMapData(ConfigMap configMap, String key, String data) {
configMap.getData().put(key, data);
- client.configMaps().inNamespace(configMap.getMetadata().getNamespace()).resource(configMap).update();
+ getConfigMapNonNamespaceOperation(configMap.getMetadata().getNamespace()).resource(configMap).update();
}
public void restartDeployment(String namespace, String deploymentName) {
diff --git a/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserService.java b/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserService.java
index aa27e22..946a696 100644
--- a/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserService.java
+++ b/src/main/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserService.java
@@ -67,12 +67,12 @@ class OzgCloudElsterTransferUserService {
public void delete(OzgCloudElsterTransferUser user) {
String namespace = user.getMetadata().getNamespace();
- if (!userExists(namespace, etrNamespace, Constants.ELSTER_TRANSFER_USER_LOGIN_KEY)) {
+ if (!userExists(namespace, etrNamespace, Constants.CONFIG_MAP_NAME)) {
LOG.info("User not exists");
return;
}
LOG.info("{} do cleanup...", user.getMetadata());
- deleteUser(user.getMetadata().getNamespace(), Constants.ELSTER_TRANSFER_USER_LOGIN_KEY);
+ deleteUser(namespace, etrNamespace);
restartDeployment(etrNamespace, Constants.ETR_DEPLOYMENT_NAME);
}
@@ -141,7 +141,7 @@ class OzgCloudElsterTransferUserService {
OzgCloudElsterTransferConfigMapUserList getUsersFromConfigMap(ConfigMap configMap) {
String usersYaml = configMap.getData().get(Constants.USERS_KEY);
- if (Objects.isNull(usersYaml)) {
+ if (Objects.isNull(usersYaml) || usersYaml.isBlank() ) {
LOG.debug("userYaml is empty");
return new OzgCloudElsterTransferConfigMapUserList(new ArrayList<>());
}
diff --git a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferConfigMapUserListTest.java b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferConfigMapUserListTest.java
index cd6719e..2aadbaf 100644
--- a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferConfigMapUserListTest.java
+++ b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferConfigMapUserListTest.java
@@ -24,7 +24,6 @@
package de.ozgcloud.operator.elstertransfer.user;
import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
import java.util.ArrayList;
import java.util.List;
@@ -110,7 +109,7 @@ class OzgCloudElsterTransferConfigMapUserListTest {
void shouldReturnEmptyListIfNoUsers() {
OzgCloudElsterTransferConfigMapUserList emptyConfigMapUserList = new OzgCloudElsterTransferConfigMapUserList(new ArrayList<>());
- assertThat(emptyConfigMapUserList.getUsersList().isEmpty()).isTrue();
+ assertThat(emptyConfigMapUserList.getUsersList()).isEmpty();
}
}
}
diff --git a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserReconcilerTest.java b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserReconcilerTest.java
index 2962849..9c8a513 100644
--- a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserReconcilerTest.java
+++ b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserReconcilerTest.java
@@ -24,7 +24,6 @@
package de.ozgcloud.operator.elstertransfer.user;
import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.DisplayName;
@@ -36,7 +35,6 @@ import org.mockito.Spy;
import de.ozgcloud.operator.ElsterTransferOperatorConfiguration;
import de.ozgcloud.operator.elstertransfer.OzgCloudCustomResourceStatus;
-import io.fabric8.kubernetes.client.KubernetesClient;
import io.javaoperatorsdk.operator.api.reconciler.DeleteControl;
class OzgCloudElsterTransferUserReconcilerTest {
@@ -75,6 +73,16 @@ class OzgCloudElsterTransferUserReconcilerTest {
assertThat(response.getResource().getStatus().getStatus()).isEqualTo(OzgCloudCustomResourceStatus.OK);
}
+ @Test
+ void shouldRescheduleOnError() {
+ doThrow(RuntimeException.class).when(service)
+ .updateConfigMapAndRestartDeploymentAndCreateSecret(OzgCloudElsterTransferUserTestFactory.METADATA_NAMESPACE);
+
+ var response = reconciler.reconcile(user, null);
+
+ assertThat(response.getResource().getStatus().getStatus()).isEqualTo(OzgCloudCustomResourceStatus.ERROR);
+ }
+
}
diff --git a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteServiceTest.java b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteServiceTest.java
index 19807c1..c341d90 100644
--- a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteServiceTest.java
+++ b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserRemoteServiceTest.java
@@ -23,7 +23,7 @@
*/
package de.ozgcloud.operator.elstertransfer.user;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
@@ -102,27 +102,48 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
private static final String deploymentName = Constants.ETR_DEPLOYMENT_NAME;
private static final String secretName = Constants.MUK_USER_SECRET_NAME;
private static final String configmapNamespace = "elster-transfer";
+ private static final String userPassword = "userPassword";
@DisplayName("test ConfigMap")
@Nested
class TestConfigMap {
@BeforeEach
void init() {
- when(client.configMaps()).thenReturn(configMapOperation);
- when(configMapOperation.inNamespace(configmapNamespace)).thenReturn(nonNamespaceOperation);
+ lenient().when(client.configMaps()).thenReturn(configMapOperation);
+ lenient().when(configMapOperation.inNamespace(configmapNamespace)).thenReturn(nonNamespaceOperation);
}
- @DisplayName("get configmap")
+ @DisplayName("get configMap")
@Nested
class TestGetConfigMap {
@Test
- void shouldCallGetConfigMap() {
+ void shouldCallGetConfigMapNonNamespaceOperation() {
+ when(nonNamespaceOperation.withName(configMapName)).thenReturn(configMapResource);
+ ConfigMap configMap = new ConfigMapBuilder()
+ .withNewMetadata()
+ .withName(configMapName)
+ .endMetadata()
+ .build();
+ when(configMapResource.get()).thenReturn(configMap);
+
+ remoteService.getConfigMap(configmapNamespace, configMapName);
+
+ verify(remoteService).getConfigMapNonNamespaceOperation(configmapNamespace);
+ }
+ @Test
+ void shouldCallWithNameGet() {
when(nonNamespaceOperation.withName(configMapName)).thenReturn(configMapResource);
+ ConfigMap configMap = new ConfigMapBuilder()
+ .withNewMetadata()
+ .withName(configMapName)
+ .endMetadata()
+ .build();
+ when(configMapResource.get()).thenReturn(configMap);
remoteService.getConfigMap(configmapNamespace, configMapName);
- verify(client.configMaps().inNamespace(configmapNamespace).withName(configMapName)).get();
+ verify(nonNamespaceOperation.withName(configMapName)).get();
}
@Test
@@ -137,11 +158,32 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
ConfigMap result = remoteService.getConfigMap(configmapNamespace, configMapName);
- assertNotNull(result);
- assert configMapName.equals(result.getMetadata().getName());
-
+ assertThat(result.getMetadata().getName()).isEqualTo(configMapName);
}
+ @DisplayName("getConfigMapNonNamespaceOperation")
+ @Nested
+ class TestgetConfigMapNonNamespaceOperation {
+
+ @Test
+ void shouldCallInNamespace() {
+ when(client.configMaps().inNamespace(configmapNamespace)).thenReturn(nonNamespaceOperation);
+
+ remoteService.getConfigMapNonNamespaceOperation(configmapNamespace);
+
+ verify(client.configMaps()).inNamespace(configmapNamespace);
+ }
+
+ @Test
+ void shouldReturnConfigMapNonNamespaceOperation() {
+ when(client.configMaps().inNamespace(configmapNamespace)).thenReturn(nonNamespaceOperation);
+
+ NonNamespaceOperation<ConfigMap, ConfigMapList, Resource<ConfigMap>> result = remoteService
+ .getConfigMapNonNamespaceOperation(configmapNamespace);
+
+ assertThat(nonNamespaceOperation).isEqualTo(result);
+ }
+ }
}
@DisplayName("create configmap")
@@ -152,31 +194,48 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@BeforeEach
void init() {
- when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource);
+ lenient().when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource);
configMap = new ConfigMapBuilder()
.withNewMetadata()
.withName(configMapName)
.endMetadata()
.build();
- when(configMapResource.create()).thenReturn(configMap);
-
}
@Test
void shouldCreateConfigMap() {
+ when(configMapResource.create()).thenReturn(configMap);when(configMapResource.create()).thenReturn(configMap);
ConfigMap result = remoteService.createConfigMap(configmapNamespace, configMapName);
- assertNotNull(result);
- assert configMapName.equals(result.getMetadata().getName());
+ assertThat(result.getMetadata().getName()).isEqualTo(configMapName);
}
@Test
- void shouldCallCreateConfigMap() {
+ void shouldCallGetConfigMapNonNamespaceOperation() {
+ remoteService.createConfigMap(configmapNamespace, configMapName);
- ConfigMap result = remoteService.createConfigMap(configmapNamespace, configMapName);
+ verify(remoteService).getConfigMapNonNamespaceOperation(configmapNamespace);
+ }
+
+ @Test
+ void shouldCallResourceCreate() {
+ remoteService.createConfigMap(configmapNamespace, configMapName);
+
+ verify(nonNamespaceOperation.resource(configMap)).create();
+ }
- verify(client.configMaps().inNamespace(configmapNamespace).resource(result)).create();
+ @DisplayName("ConfigMapBuilderTest")
+ @Nested
+ class TestConfigMapBuilder {
+
+ @Test
+ void shouldBuildConfigMap() {
+ ConfigMap result = remoteService.buildConfigMap(configMapName);
+
+ assertThat(result.getMetadata()).isNotNull();
+ assertThat(configMapName).isEqualTo(result.getMetadata().getName());
+ }
}
}
@@ -189,27 +248,33 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@BeforeEach
void init() {
-
when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource);
+ when(configMapResource.update()).thenReturn(configMap);
+
configMap.setMetadata(new io.fabric8.kubernetes.api.model.ObjectMeta());
configMap.getMetadata().setNamespace(configmapNamespace);
}
@Test
- void shouldCallUpdateConfigMapData() {
+ void shouldCallGetConfigMapNonNamespaceOperation() {
+ remoteService.updateConfigMapData(configMap, key, data);
+
+ verify(remoteService).getConfigMapNonNamespaceOperation(configmapNamespace);
+ }
+ @Test
+ void shouldCallResourceUpdate() {
remoteService.updateConfigMapData(configMap, key, data);
- verify(client.configMaps().inNamespace(configmapNamespace).resource(configMap)).update();
+ verify(nonNamespaceOperation.resource(configMap)).update();
}
@Test
void shouldUpdateConfigMapData() {
-
remoteService.updateConfigMapData(configMap, key, data);
- assert configMap.getData().containsKey(key);
- assert "new-data".equals(configMap.getData().get(key));
+ assertThat(configMap.getData()).containsKey(key);
+ assertThat(configMap.getData().get(key)).isEqualTo(data);
}
}
@@ -241,7 +306,6 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@Test
void shouldCallUpdateDeployment() {
-
when(deploymentResource.get()).thenReturn(deployment);
when(client.resource(deployment)).thenReturn(namespaceableDeployment);
@@ -263,11 +327,18 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@Test
void shouldCallGetDeployment() {
-
remoteService.restartDeployment(namespace, deploymentName);
verify(deploymentResource).get();
}
+
+ @Test
+ void shouldCallGetDeploymentResource() {
+ remoteService.restartDeployment(namespace, deploymentName);
+
+ verify(remoteService).getDeploymentResource(namespace, deploymentName);
+ }
+
}
@DisplayName("set restart flag")
@@ -280,27 +351,93 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
remoteService.setRestartAt(deployment);
- assert annotations.containsKey("kubectl.kubernetes.io/restartedAt");
- assert annotations.get("kubectl.kubernetes.io/restartedAt") != null;
+ assertThat(annotations).containsKey("kubectl.kubernetes.io/restartedAt");
+ assertThat(annotations.get("kubectl.kubernetes.io/restartedAt")).isNotNull();
+ }
+ }
+
+ @DisplayName("getDeploymentResource")
+ @Nested
+ class TestGetDeploymentResource {
+ @Test
+ void shouldGetDeploymentResource() {
+ when(client.apps()).thenReturn(appsAPIGroupDSL);
+ when(appsAPIGroupDSL.deployments()).thenReturn(deploymentOperation);
+ when(deploymentOperation.inNamespace(anyString())).thenReturn(deploymentOperation);
+ when(deploymentOperation.withName(anyString())).thenReturn(deploymentResource);
+
+ Resource<Deployment> result = remoteService.getDeploymentResource(namespace, deploymentName);
+
+ assertThat(result).isEqualTo(deploymentResource);
+ }
+
+ @Test
+ void shouldCallAppsDeploymentsInNamespaceWithName() {
+ when(client.apps()).thenReturn(appsAPIGroupDSL);
+ when(appsAPIGroupDSL.deployments()).thenReturn(deploymentOperation);
+ when(deploymentOperation.inNamespace(anyString())).thenReturn(deploymentOperation);
+ when(deploymentOperation.withName(anyString())).thenReturn(deploymentResource);
+
+ remoteService.getDeploymentResource(namespace, deploymentName);
+
+ verify(client).apps();
+ verify(client.apps()).deployments();
+ verify(client.apps().deployments()).inNamespace(namespace);
+ verify(client.apps().deployments().inNamespace(namespace)).withName(deploymentName);
}
+
}
}
- @Test
- void shouldCallCreateOrUpdateSecret() {
- String userPassword = "test-password";
- Secret secret = new SecretBuilder()
- .withNewMetadata()
- .withName(secretName)
- .endMetadata()
- .addToData("login", Base64.getEncoder().encodeToString(namespace.getBytes()))
- .addToData("password", Base64.getEncoder().encodeToString(userPassword.getBytes()))
- .build();
- when(client.resource(secret)).thenReturn(namespaceableSecret);
-
- remoteService.createOrUpdateSecret(namespace, userPassword, secretName);
-
- verify(client.resource(secret)).serverSideApply();
+ @DisplayName("createOrUpdateSecret")
+ @Nested
+ class TestCreateOrUpdateSecret {
+ Secret secret;
+ @BeforeEach
+ void setUp() {
+ secret = new SecretBuilder()
+ .withNewMetadata()
+ .withName(secretName)
+ .endMetadata()
+ .addToData("login", Base64.getEncoder().encodeToString(namespace.getBytes()))
+ .addToData("password", Base64.getEncoder().encodeToString(userPassword.getBytes()))
+ .build();
+ }
+
+ @Test
+ void shouldCallBuildUserSecret() {
+ when(client.resource(secret)).thenReturn(namespaceableSecret);
+
+ remoteService.createOrUpdateSecret(namespace, userPassword, secretName);
+
+ verify(remoteService).buildUserSecret(namespace, userPassword, secretName);
+ }
+
+ @Test
+ void shouldCallServerSideApply() {
+ when(client.resource(secret)).thenReturn(namespaceableSecret);
+
+ remoteService.createOrUpdateSecret(namespace, userPassword, secretName);
+
+ verify(client.resource(secret)).serverSideApply();
+ }
+
+ @DisplayName("buildUserSecret")
+ @Nested
+ class TestBuildUserSecret {
+
+ @Test
+ void shouldCallCreateOrUpdateSecret() {
+ Secret secret = remoteService.buildUserSecret(namespace, userPassword, secretName);
+
+ assertThat(secret.getMetadata()).isNotNull();
+ assertThat(secretName).isEqualTo(secret.getMetadata().getName());
+ assertThat(secret.getData().containsKey(Constants.ELSTER_TRANSFER_USER_LOGIN_KEY)).isTrue();
+ assertThat(secret.getData().containsKey(Constants.ELSTER_TRANSFER_USER_PASSWORD_KEY)).isTrue();
+ assertThat(secret.getData().get(Constants.ELSTER_TRANSFER_USER_LOGIN_KEY)).isEqualTo(Base64.getEncoder().encodeToString(namespace.getBytes()));
+ assertThat(secret.getData().get(Constants.ELSTER_TRANSFER_USER_PASSWORD_KEY)).isEqualTo(Base64.getEncoder().encodeToString(userPassword.getBytes()));
+ }
+ }
}
}
diff --git a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserServiceTest.java b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserServiceTest.java
index d2314f5..3372845 100644
--- a/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserServiceTest.java
+++ b/src/test/java/de/ozgcloud/operator/elstertransfer/user/OzgCloudElsterTransferUserServiceTest.java
@@ -29,19 +29,17 @@ import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
+import org.springframework.test.util.ReflectionTestUtils;
import io.fabric8.kubernetes.api.model.ConfigMap;
-import io.javaoperatorsdk.operator.api.reconciler.DeleteControl;
class OzgCloudElsterTransferUserServiceTest {
@@ -64,473 +62,553 @@ class OzgCloudElsterTransferUserServiceTest {
private static final String secretName = Constants.MUK_USER_SECRET_NAME;
private static final String configMapNamespace = "elster-transfer";
private static final String usersKey = Constants.USERS_KEY;
+ private static final String userPassword = "userPassword";
- /*
- * @Nested class TestUpdateConfigMapAndRestartDeploymentAndCreateSecret {
- *
- * @BeforeEach void setUp() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap); when(users.getUsersList()).thenReturn(
- * OzgCloudElsterTransferConfigMapUserListFactory.create());
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users); }
- *
- * @Test void shouldCallupdateConfigMapAndGenerateUserPassword() {
- * service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
- *
- * verify(service).updateConfigMapAndGenerateUserPassword(namespace,
- * configMapNamespace, configMapName); }
- *
- * @Test void shouldCallRestartDeployment() {
- * service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
- *
- * verify(service).restartDeployment(configMapNamespace, deploymentName); }
- *
- * @Test void shouldCallCreateOrUpdateSecret() { String psw = "password";
- * when(service.updateConfigMapAndGenerateUserPassword(namespace,
- * configMapNamespace, configMapName)).thenReturn(psw);
- *
- * service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
- *
- * verify(service).createOrUpdateSecret(namespace, psw, secretName); }
- *
- * @Test void shouldNotCallRestartDeployment() {
- * when(service.updateConfigMapAndGenerateUserPassword(namespace,
- * configMapNamespace, configMapName)).thenReturn("");
- *
- * service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
- *
- * verify(service, never()).restartDeployment(any(), any()); }
- *
- * @Test void shouldNotCallCreateOrUpdateSecret() {
- * when(service.updateConfigMapAndGenerateUserPassword(namespace,
- * configMapNamespace, configMapName)).thenReturn("");
- *
- * service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
- *
- * verify(service, never()).createOrUpdateSecret(any(), any(), any()); }
- *
- * }
- *
- * @Nested class Testdelete {
- *
- * @Test void keepAfterDeleteShouldReturnFalseAsDefault() {
- *
- * configMap = OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap); OzgCloudElsterTransferUser user =
- * OzgCloudElsterTransferUserTestFactory.create();
- *
- * service.delete(user);
- *
- * assertFalse(user.getSpec().isKeepAfterDelete());
- *
- * }
- *
- * @Test void shouldCallUserExists() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap);
- *
- * service.delete(OzgCloudElsterTransferUserTestFactory.create());
- *
- * verify(service).userExists(namespace, configMapNamespace, configMapName);
- *
- * }
- *
- * @Test void shouldNotCallUserExists() {
- *
- * OzgCloudElsterTransferUser user =
- * OzgCloudElsterTransferUserTestFactory.create();
- * user.getSpec().setKeepAfterDelete(true);
- *
- * service.delete(user);
- *
- * verify(service, never()).userExists(any(), any(), any());
- *
- * }
- *
- * @Test void shouldCallDeleteUser() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap); when(users.getUsersList()).thenReturn(
- * OzgCloudElsterTransferConfigMapUserListFactory.create());
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- * OzgCloudElsterTransferUser user =
- * OzgCloudElsterTransferUserTestFactory.create();
- * when(service.userExists(namespace, configMapNamespace,
- * configMapName)).thenReturn(true);
- *
- * service.delete(user);
- *
- * verify(service).deleteUser(user.getMetadata().getNamespace(), configMapName);
- * }
- *
- * @Test void shouldNotCallDeleteUserOrRestartDeploymentIfKeepAfterDelete() {
- * OzgCloudElsterTransferUser user =
- * OzgCloudElsterTransferUserTestFactory.create();
- * user.getSpec().setKeepAfterDelete(true);
- *
- * service.delete(user);
- *
- * verify(service, never()).deleteUser(any(), any()); verify(service,
- * never()).restartDeployment(any(), any()); }
- *
- * @Test void shouldNotCallDeleteUserOrRestartDeploymentIfUserNotExists() {
- * configMap = OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap); OzgCloudElsterTransferUser user =
- * OzgCloudElsterTransferUserTestFactory.create();
- * when(service.userExists(namespace, configMapNamespace,
- * configMapName)).thenReturn(false);
- *
- * service.delete(user);
- *
- * verify(service, never()).deleteUser(any(), any()); verify(service,
- * never()).restartDeployment(any(), any()); }
- *
- * @Test void shouldCallRestartDeployment() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap); when(users.getUsersList()).thenReturn(
- * OzgCloudElsterTransferConfigMapUserListFactory.create());
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- * OzgCloudElsterTransferUser user =
- * OzgCloudElsterTransferUserTestFactory.create();
- * when(service.userExists(namespace, configMapNamespace,
- * configMapName)).thenReturn(true);
- *
- * service.delete(user);
- *
- * verify(service).restartDeployment(configMapNamespace, deploymentName); } }
- *
- * @Nested
- *
- * @DisplayName("updateConfigMapAndGenerateUserPassword") class
- * TestupdateConfigMapAndGenerateUserPassword {
- *
- * @BeforeEach public void setUp() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(anyString(),
- * anyString())).thenReturn(configMap); }
- *
- * @Test void shouldNotCallCreateConfigMap() {
- * when(remoteService.getConfigMap(configMapNamespace,
- * configMapName)).thenReturn(configMap);
- *
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * verify(remoteService, never()).createConfigMap(any(), any()); }
- *
- * @Test void shouldCallGetConfigMap() {
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * verify(remoteService).getConfigMap(configMapNamespace, configMapName); }
- *
- * @Test void shouldReturnGeneratedPassword() { String userPassword =
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * assertNotNull(userPassword); }
- *
- * @Test void shouldCallUpdateConfigMap() {
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * verify(service).updateConfigMap(eq(configMapNamespace), eq(configMapName),
- * eq(configMap), anyString()); }
- *
- * @Test void shouldNotCallUpdateConfigMap() {
- * when(service.generatePassword()).thenReturn("psw");
- * when(service.addUserToUserYaml(namespace, configMap, "psw")).thenReturn("");
- *
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * verify(service, never()).updateConfigMap(any(), any(), any(), anyString()); }
- *
- * @Test void shouldSetUserPSEmptyWWhenUserYamlEmpty() {
- * when(service.generatePassword()).thenReturn("psw");
- * when(service.addUserToUserYaml(namespace, configMap, "psw")).thenReturn("");
- *
- * String userPassword =
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * assertTrue(userPassword.isEmpty()); }
- *
- * @Test void shouldSetUserPSWWhenUserYamlNotEmpty() {
- * when(service.generatePassword()).thenReturn("psw");
- * when(service.addUserToUserYaml(namespace, configMap,
- * "psw")).thenReturn("someYaml");
- *
- * String userPassword =
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * assertFalse(userPassword.isEmpty()); }
- *
- * @Test void shouldCalladdUserToUserYaml() {
- * service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
- * configMapName);
- *
- * verify(service).addUserToUserYaml(eq(namespace), eq(configMap), anyString());
- * }
- *
- * }
- *
- * @Nested class addUserToUserYamlTests {
- *
- * @Test void shouldCallgetUsersFromConfigMap() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- *
- * service.addUserToUserYaml(namespace, configMap, "password");
- *
- * verify(service).getUsersFromConfigMap(configMap); }
- *
- * @Test void shouldNotCallgetUsersFromConfigMap() {
- * service.addUserToUserYaml(namespace, null, "password");
- *
- * verify(service, never()).getUsersFromConfigMap(any()); }
- *
- * @Test void shouldCallUserExistsInList() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- * when(users.getUsersList()).thenReturn(
- * OzgCloudElsterTransferConfigMapUserListFactory.create());
- *
- * service.addUserToUserYaml(namespace, configMap, "password");
- *
- * verify(service).userExistsInList(users, namespace); }
- *
- * @Test void shouldCallAddNewUserToListWhenUserNotExists() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- * service.addUserToUserYaml(namespace, configMap, "password");
- *
- * verify(service).addNewUserToList(eq(users), eq(namespace), anyString()); }
- *
- * @Test void shouldCallconstructYamlEntries() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- * service.addUserToUserYaml(namespace, configMap, "password");
- *
- * verify(service).constructYamlEntries(users); }
- *
- * @Test void TestUserYamlShouldNotBeEmpty() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- *
- * String userYaml = service.addUserToUserYaml(namespace, configMap,
- * "password");
- *
- * assertFalse(userYaml.isEmpty()); }
- *
- * @Test void TestUserYamlShouldBeEmpty() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- *
- * String userYaml = service.addUserToUserYaml(namespace, configMap,
- * "password");
- *
- * assertTrue(userYaml.isEmpty()); } }
- *
- * @Nested class UpdateConfigMapTests {
- *
- * @Test void shouldCallCreateConfigMapIfConfigMapNotExists() {
- * service.updateConfigMap(configMapName, null, "mockedUsersYaml");
- *
- * verify(remoteService).createConfigMap(configMapNamespace, configMapName); }
- *
- * @Test void shouldNotCallCreateConfigMapIfConfigMapExists() {
- * service.updateConfigMap(configMapName, configMap, "mockedUsersYaml");
- *
- * verify(remoteService, never()).createConfigMap(any(), any()); }
- *
- * @Test void shouldCallUpdateConfigMapData() {
- * service.updateConfigMap(configMapName, configMap, "mockedUsersYaml");
- *
- * verify(remoteService).updateConfigMapData(configMap, usersKey,
- * "mockedUsersYaml"); }
- *
- * }
- *
- * @Nested class RestartDeploymentTests {
- *
- * @Test void shouldCallCreateConfigMap() {
- * service.restartDeployment(configMapNamespace, deploymentName);
- *
- * verify(remoteService).restartDeployment(configMapNamespace, deploymentName);
- * } }
- *
- * @Nested class UserExistsTests {
- *
- * @BeforeEach public void setUp() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(configMapNamespace,
- * configMapName)).thenReturn(configMap); }
- *
- * @Test void shouldCallGetConfigMap() { service.userExists(namespace,
- * configMapNamespace, configMapName);
- *
- * verify(remoteService).getConfigMap(configMapNamespace, configMapName); }
- *
- * @Test void shouldReturnUserExistsTrueIfUserExists() {
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- * when(users.existsUser(namespace)).thenReturn(true);
- *
- * boolean userExists = service.userExists(namespace, configMapNamespace,
- * configMapName);
- *
- * assertTrue(userExists); }
- *
- * @Test void shouldReturnUserExistsTrueIfUserNotExists() { boolean userExists =
- * service.userExists(namespace, configMapNamespace, configMapName);
- *
- * assertFalse(userExists); }
- *
- * @Test void shouldCallgetUsersFromConfigMap() { service.userExists(namespace,
- * configMapNamespace, configMapName);
- *
- * verify(service).getUsersFromConfigMap(configMap); }
- *
- * @Test void shouldCallExistsUser() {
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- * service.userExists(namespace, configMapNamespace, configMapName);
- *
- * verify(users).existsUser(namespace); }
- *
- * }
- *
- * @Nested class DeleteUserTests {
- *
- * @BeforeEach public void setUp() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create();
- * when(remoteService.getConfigMap(configMapNamespace,
- * configMapName)).thenReturn(configMap); }
- *
- * @Test void shouldCallGetConfigMap() { service.deleteUser(namespace,
- * configMapName);
- *
- * verify(remoteService).getConfigMap(configMapNamespace, configMapName); }
- *
- * @Test void shouldCallGetUsersFromConfigMap() { service.deleteUser(namespace,
- * configMapName);
- *
- * verify(service).getUsersFromConfigMap(configMap); }
- *
- * @Test void shouldCallremoveDeleted() {
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- * service.deleteUser(namespace, configMapName);
- *
- * verify(users).removeDeleted(namespace); }
- *
- * @Test void ShouldCallConstructYamlEntries() {
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- *
- * service.deleteUser(namespace, configMapName);
- *
- * verify(service).constructYamlEntries(users); }
- *
- * @Test void ShouldCallUpdateConfigMapData() {
- * when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
- * when(service.constructYamlEntries(users)).thenReturn("updatedUsersYaml");
- *
- * service.deleteUser(namespace, configMapName);
- *
- * verify(remoteService).updateConfigMapData(configMap, usersKey,
- * "updatedUsersYaml"); } }
- *
- * @Nested class CreateOrUpdateSecretTests {
- *
- * @Test void shouldCallCreateOrUpdateSecret() {
- * service.createOrUpdateSecret(namespace, "psw", secretName);
- *
- * verify(remoteService).createOrUpdateSecret(namespace, "psw", secretName); }
- *
- * }
- *
- * @Nested class GetUsersFromConfigMapTests {
- *
- * @BeforeEach public void setUp() { configMap =
- * OzgCloudElsterTransferConfigMapFactory.create(); }
- *
- * @Test void shouldReturnObjectConfigMapUserList() {
- * OzgCloudElsterTransferConfigMapUserList result =
- * service.getUsersFromConfigMap(configMap);
- *
- * assertNotNull(result);
- * assertInstanceOf(OzgCloudElsterTransferConfigMapUserList.class, result); }
- *
- * @Test void shouldReturnConfigMapUserListWithContent() {
- * OzgCloudElsterTransferConfigMapUserList result =
- * service.getUsersFromConfigMap(configMap);
- *
- * List<Map<String, Object>> usersList = result.getUsersList();
- *
- * assertThat(usersList).hasSize(1); }
- *
- * }
- *
- * @Nested class UserExistsInListTests {
- *
- * @Test void shouldCallExistsUser() { service.userExistsInList(users,
- * namespace);
- *
- * verify(users).existsUser(namespace); }
- *
- * }
- *
- * @Nested class AddNewUserToListTests {
- *
- * @Test void shouldCallAddUserToList() { service.addNewUserToList(users,
- * namespace, "pswHash");
- *
- * verify(users).addUserToList(namespace, "pswHash", "USER"); }
- *
- * }
- *
- * @Nested class ConstructYamlEntriesTests {
- *
- * @Test void shouldHaveResultWithCorrectContentStart() { String result =
- * service.constructYamlEntries(users);
- *
- * assertTrue(result.startsWith("fileFormat: 1\nusers:\n")); }
- *
- * @Test void shouldHaveResultWithCorrectContent() {
- * when(users.getUsersList()).thenReturn(
- * OzgCloudElsterTransferConfigMapUserListFactory.create()); String expectedYaml
- * = "fileFormat: 1\n" + "users:\n" +
- * " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }\n"
- * ;
- *
- * String result = service.constructYamlEntries(users);
- *
- * assertThat(expectedYaml).isEqualTo(result); } }
- *
- * @Nested class GetYamlForUserTests {
- *
- * @Test void shouldReturnExpectedYamlForUser() { Map<String, Object> userEntry
- * = new HashMap<>(); userEntry.put("login", "user1"); userEntry.put("rolle",
- * "USER"); userEntry.put("gruppe", "user1"); Map<String, String> credentials =
- * new HashMap<>(); credentials.put("passwortHash",
- * "$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a");
- * userEntry.put("credentials", credentials); String expectedYaml =
- * " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }\n"
- * ;
- *
- * String result = service.getYamlForUser(userEntry);
- *
- * assertThat(expectedYaml).isEqualTo(result); }
- *
- * }
- */
-}
+ @Nested
+ class TestUpdateConfigMapAndRestartDeploymentAndCreateSecret {
+
+ @BeforeEach
+ void setUp() {
+ configMap = OzgCloudElsterTransferConfigMapFactory.create();
+ lenient().when(remoteService.getConfigMap(anyString(),
+ anyString())).thenReturn(configMap);
+ ReflectionTestUtils.setField(service, "etrNamespace", "elster-transfer");
+ }
+
+ @Test
+ void shouldCallUserExists() {
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service).userExists(namespace, configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallupdateConfigMapAndGenerateUserPasswordIfUserNotExists() {
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service).updateConfigMapAndGenerateUserPassword(namespace,
+ configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallRestartDeploymentIfUserNotExists() {
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service).restartDeployment(configMapNamespace, deploymentName);
+ }
+
+ @Test
+ void shouldCallCreateOrUpdateSecretIfUserNotExists() {
+ when(service.updateConfigMapAndGenerateUserPassword(namespace,
+ configMapNamespace, configMapName)).thenReturn(userPassword);
+
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service).createOrUpdateSecret(namespace, userPassword, secretName);
+ }
+
+ @Test
+ void shouldNotCallRestartDeploymentIfUserExists() {
+ when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
+
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service, never()).restartDeployment(any(), any());
+ }
+
+ @Test
+ void shouldNotCallUpdateConfigMapAndGenerateUserPasswordIfUserExists() {
+ when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
+
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service, never()).updateConfigMapAndGenerateUserPassword(any(), any(), any());
+ }
+
+ @Test
+ void shouldNotCallCreateOrUpdateSecretIfUserExists() {
+ when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
+
+ service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
+
+ verify(service, never()).createOrUpdateSecret(any(), any(), any());
+ }
+
+ @Nested
+ class TestUpdateConfigMapAndGenerateUserPassword {
+
+ @Test
+ void shouldCallCreateOrGetConfigMap() {
+ service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
+
+ verify(service).createOrGetConfigMap(configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallGeneratePassword() {
+ service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
+
+ verify(service).generatePassword();
+ }
+
+ @Test
+ void shouldCallAddUserToUserYaml() {
+ service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
+
+ verify(service).addUserToUserYaml(any(), any(), any());
+ }
+
+ @Test
+ void shouldCallGetUsersFromConfigMap() {
+ when(service.createOrGetConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+
+ service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
+
+ verify(service).getUsersFromConfigMap(configMap);
+ }
+
+ @Test
+ void shouldCallUpdateConfigMap() {
+ String usersYaml = "usersYaml";
+ when(service.createOrGetConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.generatePassword()).thenReturn(userPassword);
+ when(service.addUserToUserYaml(users, namespace, userPassword)).thenReturn(usersYaml);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+
+ service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
+
+ verify(service).updateConfigMap(configMapName, configMap, usersYaml);
+ }
+
+ @Test
+ void shouldReturnUserPassword() {
+ when(service.generatePassword()).thenReturn(userPassword);
+
+ String result = service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
+
+ assertThat(result).isEqualTo(userPassword);
+ }
+
+ @Nested
+ class TestCreateOrGetConfigMap {
+
+ @Test
+ void shouldCallGetConfigMap() {
+ service.createOrGetConfigMap(configMapNamespace, configMapName);
+
+ verify(service).getConfigMap(configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallCreateConfigMap() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
+
+ service.createOrGetConfigMap(configMapNamespace, configMapName);
+
+ verify(remoteService).createConfigMap(configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCreateConfigMap() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
+ when(remoteService.createConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+
+ ConfigMap result = service.createOrGetConfigMap(configMapNamespace, configMapName);
+
+ assertThat(result).isEqualTo(configMap);
+
+ }
+
+ @Test
+ void shouldNotCallCreateConfigMap() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+
+ service.createOrGetConfigMap(configMapNamespace, configMapName);
+
+ verify(remoteService, never()).createConfigMap(any(), any());
+ }
+
+ @Nested
+ class TestGetConfigMap {
+
+ @Test
+ void shouldCallGetConfigMap() {
+ service.getConfigMap(configMapNamespace, configMapName);
+
+ verify(remoteService).getConfigMap(configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldReturnConfigMap() {
+ when(remoteService.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+
+ ConfigMap result = service.getConfigMap(configMapNamespace, configMapName);
+
+ assertThat(result).isEqualTo(configMap);
+ }
+
+ }
+
+ }
+
+ @Nested
+ class TestAddUserToUserYaml {
+ @Test
+ void shouldCallAddNewUserToList() {
+ service.addUserToUserYaml(users, namespace, userPassword);
+
+ verify(service).addNewUserToList(eq(users), eq(namespace), anyString());
+ }
+
+ @Test
+ void shouldCallConstructYamlEntries() {
+ service.addUserToUserYaml(users, namespace, userPassword);
+
+ verify(service).constructYamlEntries(users);
+ }
+
+ @Test
+ void shouldReturnUsersYaml() {
+ when(service.constructYamlEntries(users)).thenReturn("usersYaml");
+
+ String result = service.addUserToUserYaml(users, namespace, userPassword);
+
+ assertThat(result).isEqualTo("usersYaml");
+ }
+
+ @Nested
+ class TestAddNewUserToList {
+ @Test
+ void shouldCallAddUserToList() {
+ service.addNewUserToList(users, namespace, "passwordHash");
+
+ verify(users).addUserToList(namespace, "passwordHash", Constants.USER_ROLE);
+
+ }
+ }
+
+ @Nested
+ class TestConstructYamlEntries {
+ @Test
+ void shouldCallGetUsersList() {
+ service.constructYamlEntries(users);
+
+ verify(users).getUsersList();
+
+ }
+
+ @Test
+ void shouldHaveResultWithCorrectContentStart() {
+ String result = service.constructYamlEntries(users);
+
+ assertTrue(result.startsWith("fileFormat: 1\nusers:\n"));
+ }
+
+ @Test
+ void shouldHaveResultWithCorrectContent() {
+ when(users.getUsersList()).thenReturn(
+ OzgCloudElsterTransferConfigMapUserListFactory.create());
+ String expectedYaml = "fileFormat: 1\n" + "users:\n" +
+ " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }\n";
+
+ String result = service.constructYamlEntries(users);
+
+ assertThat(expectedYaml).isEqualTo(result);
+ }
+
+ @Nested
+ class TestGetYamlForUser {
+ @Test
+ void shouldReturnExpectedYamlForUser() {
+ Map<String, Object> userEntry = new HashMap<>();
+ userEntry.put("login", "user1");
+ userEntry.put("rolle",
+ "USER");
+ userEntry.put("gruppe", "user1");
+ Map<String, String> credentials = new HashMap<>();
+ credentials.put("passwortHash",
+ "$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a");
+ userEntry.put("credentials", credentials);
+ String expectedYaml = " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }";
+
+ String result = service.getYamlForUser(userEntry);
+
+ assertThat(expectedYaml).isEqualTo(result);
+ }
+
+ }
+
+ }
+
+ }
+
+ @Nested
+ class TestUpdateConfigMap {
+ @Test
+ void shouldCallUpdateConfigMapData() {
+ service.updateConfigMap(configMapName, configMap, "usersYaml");
+
+ verify(remoteService).updateConfigMapData(configMap, usersKey, "usersYaml");
+ }
+ }
+
+ @Nested
+ class TestGetUsersFromConfigMap {
+ @Test
+ void shouldReturnEmptyUserList() {
+ ConfigMap configMap = new ConfigMap();
+ configMap.setData(new HashMap<>());
+
+ OzgCloudElsterTransferConfigMapUserList result = service.getUsersFromConfigMap(configMap);
+
+ assertThat(result.getUsersList()).isEmpty();
+ }
+
+ @Test
+ void shouldReturnEmptyUserListWhenUsersYamlIsEmpty() {
+ ConfigMap configMap = new ConfigMap();
+ Map<String, String> data = new HashMap<>();
+ data.put(usersKey, "");
+ configMap.setData(data);
+
+ OzgCloudElsterTransferConfigMapUserList result = service.getUsersFromConfigMap(configMap);
+
+ assertNotNull(result);
+ assertThat(result.getUsersList()).isEmpty();
+ }
+
+ void shouldReturnParsedUserListWhenUsersYamlIsValid() {
+ ConfigMap configMap = OzgCloudElsterTransferConfigMapFactory.create();
+
+ OzgCloudElsterTransferConfigMapUserList result = service.getUsersFromConfigMap(configMap);
+ Map<String, Object> user1 = result.getUsersList().get(0);
+
+ assertThat(result.getUsersList()).hasSize(1);
+ assertThat(user1.get("login")).isEqualTo("admin");
+ assertThat(user1.get("role")).isEqualTo("ADMIN");
+ assertThat(user1.get("passwordHash")).isEqualTo("$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a");
+ assertThat(user1.get("group")).isEqualTo("Administratoren");
+ }
+
+ }
+
+ }
+
+ @Nested
+ class TestRestartDeployment {
+
+ @Test
+ void shouldCallRestartDeployment() {
+ service.restartDeployment(configMapNamespace, deploymentName);
+
+ verify(remoteService).restartDeployment(configMapNamespace, deploymentName);
+ }
+
+ }
+
+ @Nested
+ class TestCreateOrUpdateSecret {
+
+ @Test
+ void shouldCallRestartDeployment() {
+ service.createOrUpdateSecret(namespace, userPassword, secretName);
+
+ verify(remoteService).createOrUpdateSecret(namespace, userPassword, secretName);
+ }
+
+ }
+
+ }
+
+ @Nested
+ class TestDelete {
+
+ @BeforeEach
+ void setUp() {
+ ReflectionTestUtils.setField(service, "etrNamespace", "elster-transfer");
+ }
+
+ @Test
+ void shouldCallUserExists() {
+ service.delete(OzgCloudElsterTransferUserTestFactory.create());
+
+ verify(service).userExists(namespace, configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallDeleteUser() {
+ when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
+ configMap = OzgCloudElsterTransferConfigMapFactory.create();
+ when(remoteService.getConfigMap(anyString(),
+ anyString())).thenReturn(configMap);
+
+ service.delete(OzgCloudElsterTransferUserTestFactory.create());
+
+ verify(service).deleteUser(namespace, configMapNamespace);
+ }
+
+ @Test
+ void shouldCallRestartDeployment() {
+ when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
+ configMap = OzgCloudElsterTransferConfigMapFactory.create();
+ when(remoteService.getConfigMap(anyString(),
+ anyString())).thenReturn(configMap);
+
+ service.delete(OzgCloudElsterTransferUserTestFactory.create());
+
+ verify(service).restartDeployment(configMapNamespace, deploymentName);
+ }
+
+ @Test
+ void shouldNotCallRestartDeploymentIfUserNotExists() {
+ service.delete(OzgCloudElsterTransferUserTestFactory.create());
+
+ verify(service, never()).restartDeployment(any(), any());
+ }
+
+ @Test
+ void shouldNotCallDeleteUserIfUserNotExists() {
+ service.delete(OzgCloudElsterTransferUserTestFactory.create());
+
+ verify(service, never()).deleteUser(any(), any());
+ }
+
+ @Nested
+ class TestUserExists {
+
+ @Test
+ void shouldCallGetConfigMap() {
+ service.userExists(namespace, configMapNamespace, configMapName);
+
+ verify(service).getConfigMap(configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallGetUsersFromConfigMap() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+
+ service.userExists(namespace, configMapNamespace, configMapName);
+
+ verify(service).getUsersFromConfigMap(configMap);
+ }
+
+ @Test
+ void shouldNotCallGetUsersFromConfigMap() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
+
+ service.userExists(namespace, configMapNamespace, configMapName);
+
+ verify(service, never()).getUsersFromConfigMap(any());
+ }
+
+ @Test
+ void shouldCallExistsUser() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+
+ service.userExists(namespace, configMapNamespace, configMapName);
+
+ verify(users, times(2)).existsUser(namespace);
+ }
+
+ @Test
+ void shouldNotCallExistsUser() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
+
+ service.userExists(namespace, configMapNamespace, configMapName);
+
+ verify(users, never()).existsUser(any());
+ }
+
+ @Test
+ void shouldReturnFalseWhenConfigMapNotExists() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
+
+ boolean result = service.userExists(namespace, configMapNamespace, configMapName);
+
+ assertThat(result).isFalse();
+ }
+
+ @Test
+ void shouldReturnTrueWhenConfigMapExistsAndUserExists() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+ when(users.existsUser(namespace)).thenReturn(true);
+
+ boolean result = service.userExists(namespace, configMapNamespace, configMapName);
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ void shouldReturnFalseWhenConfigMapExistsButUserNotExists() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+ when(users.existsUser(namespace)).thenReturn(false);
+
+ boolean result = service.userExists(namespace, configMapNamespace, configMapName);
+
+ assertThat(result).isFalse();
+ }
+
+ }
+
+ @Nested
+ class TestDeleteUser {
+
+ @BeforeEach
+ void setUp() {
+ configMap = OzgCloudElsterTransferConfigMapFactory.create();
+ when(remoteService.getConfigMap(anyString(),
+ anyString())).thenReturn(configMap);
+ }
+
+ @Test
+ void shouldCallGetConfigMap() {
+ service.deleteUser(namespace, configMapName);
+
+ verify(service).getConfigMap(configMapNamespace, configMapName);
+ }
+
+ @Test
+ void shouldCallGetUsersFromConfigMap() {
+ service.deleteUser(namespace, configMapName);
+
+ verify(service).getUsersFromConfigMap(configMap);
+ }
+
+ @Test
+ void shouldCallRemoveDeleted() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+
+ service.deleteUser(namespace, configMapName);
+
+ verify(users).removeDeleted(namespace);
+ }
+
+ @Test
+ void shouldCallConstructYamlEntries() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+
+ service.deleteUser(namespace, configMapName);
+
+ verify(service).constructYamlEntries(users);
+ }
+
+ @Test
+ void shouldCallUpdateConfigMapData() {
+ when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
+ when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
+ when(service.constructYamlEntries(users)).thenReturn("updatedUsersYaml");
+
+ service.deleteUser(namespace, configMapName);
+
+ verify(remoteService).updateConfigMapData(configMap, usersKey, "updatedUsersYaml");
+ }
+
+ }
+
+ }
+}
\ No newline at end of file
--
GitLab