Skip to content
Snippets Groups Projects
Commit 0746fbe0 authored by OZGCloud's avatar OZGCloud
Browse files

update junittests

parent ec1ae070
Branches
Tags
No related merge requests found
...@@ -67,7 +67,7 @@ class OzgCloudElsterTransferUserRemoteService { ...@@ -67,7 +67,7 @@ class OzgCloudElsterTransferUserRemoteService {
public void updateConfigMapData(ConfigMap configMap, String key, String data) { public void updateConfigMapData(ConfigMap configMap, String key, String data) {
configMap.getData().put(key, 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) { public void restartDeployment(String namespace, String deploymentName) {
......
...@@ -67,12 +67,12 @@ class OzgCloudElsterTransferUserService { ...@@ -67,12 +67,12 @@ class OzgCloudElsterTransferUserService {
public void delete(OzgCloudElsterTransferUser user) { public void delete(OzgCloudElsterTransferUser user) {
String namespace = user.getMetadata().getNamespace(); 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"); LOG.info("User not exists");
return; return;
} }
LOG.info("{} do cleanup...", user.getMetadata()); 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); restartDeployment(etrNamespace, Constants.ETR_DEPLOYMENT_NAME);
} }
...@@ -141,7 +141,7 @@ class OzgCloudElsterTransferUserService { ...@@ -141,7 +141,7 @@ class OzgCloudElsterTransferUserService {
OzgCloudElsterTransferConfigMapUserList getUsersFromConfigMap(ConfigMap configMap) { OzgCloudElsterTransferConfigMapUserList getUsersFromConfigMap(ConfigMap configMap) {
String usersYaml = configMap.getData().get(Constants.USERS_KEY); String usersYaml = configMap.getData().get(Constants.USERS_KEY);
if (Objects.isNull(usersYaml)) { if (Objects.isNull(usersYaml) || usersYaml.isBlank() ) {
LOG.debug("userYaml is empty"); LOG.debug("userYaml is empty");
return new OzgCloudElsterTransferConfigMapUserList(new ArrayList<>()); return new OzgCloudElsterTransferConfigMapUserList(new ArrayList<>());
} }
......
...@@ -24,7 +24,6 @@ ...@@ -24,7 +24,6 @@
package de.ozgcloud.operator.elstertransfer.user; package de.ozgcloud.operator.elstertransfer.user;
import static org.assertj.core.api.Assertions.*; import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
...@@ -110,7 +109,7 @@ class OzgCloudElsterTransferConfigMapUserListTest { ...@@ -110,7 +109,7 @@ class OzgCloudElsterTransferConfigMapUserListTest {
void shouldReturnEmptyListIfNoUsers() { void shouldReturnEmptyListIfNoUsers() {
OzgCloudElsterTransferConfigMapUserList emptyConfigMapUserList = new OzgCloudElsterTransferConfigMapUserList(new ArrayList<>()); OzgCloudElsterTransferConfigMapUserList emptyConfigMapUserList = new OzgCloudElsterTransferConfigMapUserList(new ArrayList<>());
assertThat(emptyConfigMapUserList.getUsersList().isEmpty()).isTrue(); assertThat(emptyConfigMapUserList.getUsersList()).isEmpty();
} }
} }
} }
...@@ -24,7 +24,6 @@ ...@@ -24,7 +24,6 @@
package de.ozgcloud.operator.elstertransfer.user; package de.ozgcloud.operator.elstertransfer.user;
import static org.assertj.core.api.Assertions.*; import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.DisplayName;
...@@ -36,7 +35,6 @@ import org.mockito.Spy; ...@@ -36,7 +35,6 @@ import org.mockito.Spy;
import de.ozgcloud.operator.ElsterTransferOperatorConfiguration; import de.ozgcloud.operator.ElsterTransferOperatorConfiguration;
import de.ozgcloud.operator.elstertransfer.OzgCloudCustomResourceStatus; import de.ozgcloud.operator.elstertransfer.OzgCloudCustomResourceStatus;
import io.fabric8.kubernetes.client.KubernetesClient;
import io.javaoperatorsdk.operator.api.reconciler.DeleteControl; import io.javaoperatorsdk.operator.api.reconciler.DeleteControl;
class OzgCloudElsterTransferUserReconcilerTest { class OzgCloudElsterTransferUserReconcilerTest {
...@@ -75,6 +73,16 @@ class OzgCloudElsterTransferUserReconcilerTest { ...@@ -75,6 +73,16 @@ class OzgCloudElsterTransferUserReconcilerTest {
assertThat(response.getResource().getStatus().getStatus()).isEqualTo(OzgCloudCustomResourceStatus.OK); 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);
}
} }
......
...@@ -23,7 +23,7 @@ ...@@ -23,7 +23,7 @@
*/ */
package de.ozgcloud.operator.elstertransfer.user; 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.ArgumentMatchers.*;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
...@@ -102,27 +102,48 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -102,27 +102,48 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
private static final String deploymentName = Constants.ETR_DEPLOYMENT_NAME; private static final String deploymentName = Constants.ETR_DEPLOYMENT_NAME;
private static final String secretName = Constants.MUK_USER_SECRET_NAME; private static final String secretName = Constants.MUK_USER_SECRET_NAME;
private static final String configmapNamespace = "elster-transfer"; private static final String configmapNamespace = "elster-transfer";
private static final String userPassword = "userPassword";
@DisplayName("test ConfigMap") @DisplayName("test ConfigMap")
@Nested @Nested
class TestConfigMap { class TestConfigMap {
@BeforeEach @BeforeEach
void init() { void init() {
when(client.configMaps()).thenReturn(configMapOperation); lenient().when(client.configMaps()).thenReturn(configMapOperation);
when(configMapOperation.inNamespace(configmapNamespace)).thenReturn(nonNamespaceOperation); lenient().when(configMapOperation.inNamespace(configmapNamespace)).thenReturn(nonNamespaceOperation);
} }
@DisplayName("get configmap") @DisplayName("get configMap")
@Nested @Nested
class TestGetConfigMap { class TestGetConfigMap {
@Test @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); when(nonNamespaceOperation.withName(configMapName)).thenReturn(configMapResource);
ConfigMap configMap = new ConfigMapBuilder()
.withNewMetadata()
.withName(configMapName)
.endMetadata()
.build();
when(configMapResource.get()).thenReturn(configMap);
remoteService.getConfigMap(configmapNamespace, configMapName); remoteService.getConfigMap(configmapNamespace, configMapName);
verify(client.configMaps().inNamespace(configmapNamespace).withName(configMapName)).get(); verify(nonNamespaceOperation.withName(configMapName)).get();
} }
@Test @Test
...@@ -137,11 +158,32 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -137,11 +158,32 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
ConfigMap result = remoteService.getConfigMap(configmapNamespace, configMapName); ConfigMap result = remoteService.getConfigMap(configmapNamespace, configMapName);
assertNotNull(result); assertThat(result.getMetadata().getName()).isEqualTo(configMapName);
assert configMapName.equals(result.getMetadata().getName()); }
@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") @DisplayName("create configmap")
...@@ -152,31 +194,48 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -152,31 +194,48 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@BeforeEach @BeforeEach
void init() { void init() {
when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource); lenient().when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource);
configMap = new ConfigMapBuilder() configMap = new ConfigMapBuilder()
.withNewMetadata() .withNewMetadata()
.withName(configMapName) .withName(configMapName)
.endMetadata() .endMetadata()
.build(); .build();
when(configMapResource.create()).thenReturn(configMap);
} }
@Test @Test
void shouldCreateConfigMap() { void shouldCreateConfigMap() {
when(configMapResource.create()).thenReturn(configMap);when(configMapResource.create()).thenReturn(configMap);
ConfigMap result = remoteService.createConfigMap(configmapNamespace, configMapName); ConfigMap result = remoteService.createConfigMap(configmapNamespace, configMapName);
assertNotNull(result); assertThat(result.getMetadata().getName()).isEqualTo(configMapName);
assert configMapName.equals(result.getMetadata().getName());
} }
@Test @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(client.configMaps().inNamespace(configmapNamespace).resource(result)).create(); verify(nonNamespaceOperation.resource(configMap)).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 { ...@@ -189,27 +248,33 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@BeforeEach @BeforeEach
void init() { void init() {
when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource); when(nonNamespaceOperation.resource(any(ConfigMap.class))).thenReturn(configMapResource);
when(configMapResource.update()).thenReturn(configMap);
configMap.setMetadata(new io.fabric8.kubernetes.api.model.ObjectMeta()); configMap.setMetadata(new io.fabric8.kubernetes.api.model.ObjectMeta());
configMap.getMetadata().setNamespace(configmapNamespace); configMap.getMetadata().setNamespace(configmapNamespace);
} }
@Test @Test
void shouldCallUpdateConfigMapData() { void shouldCallGetConfigMapNonNamespaceOperation() {
remoteService.updateConfigMapData(configMap, key, data);
verify(remoteService).getConfigMapNonNamespaceOperation(configmapNamespace);
}
@Test
void shouldCallResourceUpdate() {
remoteService.updateConfigMapData(configMap, key, data); remoteService.updateConfigMapData(configMap, key, data);
verify(client.configMaps().inNamespace(configmapNamespace).resource(configMap)).update(); verify(nonNamespaceOperation.resource(configMap)).update();
} }
@Test @Test
void shouldUpdateConfigMapData() { void shouldUpdateConfigMapData() {
remoteService.updateConfigMapData(configMap, key, data); remoteService.updateConfigMapData(configMap, key, data);
assert configMap.getData().containsKey(key); assertThat(configMap.getData()).containsKey(key);
assert "new-data".equals(configMap.getData().get(key)); assertThat(configMap.getData().get(key)).isEqualTo(data);
} }
} }
...@@ -241,7 +306,6 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -241,7 +306,6 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@Test @Test
void shouldCallUpdateDeployment() { void shouldCallUpdateDeployment() {
when(deploymentResource.get()).thenReturn(deployment); when(deploymentResource.get()).thenReturn(deployment);
when(client.resource(deployment)).thenReturn(namespaceableDeployment); when(client.resource(deployment)).thenReturn(namespaceableDeployment);
...@@ -263,11 +327,18 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -263,11 +327,18 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
@Test @Test
void shouldCallGetDeployment() { void shouldCallGetDeployment() {
remoteService.restartDeployment(namespace, deploymentName); remoteService.restartDeployment(namespace, deploymentName);
verify(deploymentResource).get(); verify(deploymentResource).get();
} }
@Test
void shouldCallGetDeploymentResource() {
remoteService.restartDeployment(namespace, deploymentName);
verify(remoteService).getDeploymentResource(namespace, deploymentName);
}
} }
@DisplayName("set restart flag") @DisplayName("set restart flag")
...@@ -280,22 +351,70 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -280,22 +351,70 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
remoteService.setRestartAt(deployment); remoteService.setRestartAt(deployment);
assert annotations.containsKey("kubectl.kubernetes.io/restartedAt"); assertThat(annotations).containsKey("kubectl.kubernetes.io/restartedAt");
assert annotations.get("kubectl.kubernetes.io/restartedAt") != null; 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 @Test
void shouldCallCreateOrUpdateSecret() { void shouldCallAppsDeploymentsInNamespaceWithName() {
String userPassword = "test-password"; when(client.apps()).thenReturn(appsAPIGroupDSL);
Secret secret = new SecretBuilder() 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);
}
}
}
@DisplayName("createOrUpdateSecret")
@Nested
class TestCreateOrUpdateSecret {
Secret secret;
@BeforeEach
void setUp() {
secret = new SecretBuilder()
.withNewMetadata() .withNewMetadata()
.withName(secretName) .withName(secretName)
.endMetadata() .endMetadata()
.addToData("login", Base64.getEncoder().encodeToString(namespace.getBytes())) .addToData("login", Base64.getEncoder().encodeToString(namespace.getBytes()))
.addToData("password", Base64.getEncoder().encodeToString(userPassword.getBytes())) .addToData("password", Base64.getEncoder().encodeToString(userPassword.getBytes()))
.build(); .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); when(client.resource(secret)).thenReturn(namespaceableSecret);
remoteService.createOrUpdateSecret(namespace, userPassword, secretName); remoteService.createOrUpdateSecret(namespace, userPassword, secretName);
...@@ -303,4 +422,22 @@ class OzgCloudElsterTransferUserRemoteServiceTest { ...@@ -303,4 +422,22 @@ class OzgCloudElsterTransferUserRemoteServiceTest {
verify(client.resource(secret)).serverSideApply(); 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()));
}
}
}
} }
...@@ -29,19 +29,17 @@ import static org.mockito.ArgumentMatchers.*; ...@@ -29,19 +29,17 @@ import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
import java.util.HashMap; import java.util.HashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Spy; import org.mockito.Spy;
import org.springframework.test.util.ReflectionTestUtils;
import io.fabric8.kubernetes.api.model.ConfigMap; import io.fabric8.kubernetes.api.model.ConfigMap;
import io.javaoperatorsdk.operator.api.reconciler.DeleteControl;
class OzgCloudElsterTransferUserServiceTest { class OzgCloudElsterTransferUserServiceTest {
...@@ -64,473 +62,553 @@ class OzgCloudElsterTransferUserServiceTest { ...@@ -64,473 +62,553 @@ class OzgCloudElsterTransferUserServiceTest {
private static final String secretName = Constants.MUK_USER_SECRET_NAME; private static final String secretName = Constants.MUK_USER_SECRET_NAME;
private static final String configMapNamespace = "elster-transfer"; private static final String configMapNamespace = "elster-transfer";
private static final String usersKey = Constants.USERS_KEY; private static final String usersKey = Constants.USERS_KEY;
private static final String userPassword = "userPassword";
/* @Nested
* @Nested class TestUpdateConfigMapAndRestartDeploymentAndCreateSecret { class TestUpdateConfigMapAndRestartDeploymentAndCreateSecret {
*
* @BeforeEach void setUp() { configMap = @BeforeEach
* OzgCloudElsterTransferConfigMapFactory.create(); void setUp() {
* when(remoteService.getConfigMap(anyString(), configMap = OzgCloudElsterTransferConfigMapFactory.create();
* anyString())).thenReturn(configMap); when(users.getUsersList()).thenReturn( lenient().when(remoteService.getConfigMap(anyString(),
* OzgCloudElsterTransferConfigMapUserListFactory.create()); anyString())).thenReturn(configMap);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); } ReflectionTestUtils.setField(service, "etrNamespace", "elster-transfer");
* }
* @Test void shouldCallupdateConfigMapAndGenerateUserPassword() {
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace); @Test
* void shouldCallUserExists() {
* verify(service).updateConfigMapAndGenerateUserPassword(namespace, service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
* configMapNamespace, configMapName); }
* verify(service).userExists(namespace, configMapNamespace, configMapName);
* @Test void shouldCallRestartDeployment() { }
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
* @Test
* verify(service).restartDeployment(configMapNamespace, deploymentName); } void shouldCallupdateConfigMapAndGenerateUserPasswordIfUserNotExists() {
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
* @Test void shouldCallCreateOrUpdateSecret() { String psw = "password";
* when(service.updateConfigMapAndGenerateUserPassword(namespace, verify(service).updateConfigMapAndGenerateUserPassword(namespace,
* configMapNamespace, configMapName)).thenReturn(psw); configMapNamespace, configMapName);
* }
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
* @Test
* verify(service).createOrUpdateSecret(namespace, psw, secretName); } void shouldCallRestartDeploymentIfUserNotExists() {
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
* @Test void shouldNotCallRestartDeployment() {
* when(service.updateConfigMapAndGenerateUserPassword(namespace, verify(service).restartDeployment(configMapNamespace, deploymentName);
* configMapNamespace, configMapName)).thenReturn(""); }
*
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace); @Test
* void shouldCallCreateOrUpdateSecretIfUserNotExists() {
* verify(service, never()).restartDeployment(any(), any()); } when(service.updateConfigMapAndGenerateUserPassword(namespace,
* configMapNamespace, configMapName)).thenReturn(userPassword);
* @Test void shouldNotCallCreateOrUpdateSecret() {
* when(service.updateConfigMapAndGenerateUserPassword(namespace, service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
* configMapNamespace, configMapName)).thenReturn("");
* verify(service).createOrUpdateSecret(namespace, userPassword, secretName);
* service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace); }
*
* verify(service, never()).createOrUpdateSecret(any(), any(), any()); } @Test
* void shouldNotCallRestartDeploymentIfUserExists() {
* } when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
*
* @Nested class Testdelete { service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
*
* @Test void keepAfterDeleteShouldReturnFalseAsDefault() { verify(service, never()).restartDeployment(any(), any());
* }
* configMap = OzgCloudElsterTransferConfigMapFactory.create();
* when(remoteService.getConfigMap(anyString(), @Test
* anyString())).thenReturn(configMap); OzgCloudElsterTransferUser user = void shouldNotCallUpdateConfigMapAndGenerateUserPasswordIfUserExists() {
* OzgCloudElsterTransferUserTestFactory.create(); when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
*
* service.delete(user); service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
*
* assertFalse(user.getSpec().isKeepAfterDelete()); verify(service, never()).updateConfigMapAndGenerateUserPassword(any(), any(), any());
* }
* }
* @Test
* @Test void shouldCallUserExists() { configMap = void shouldNotCallCreateOrUpdateSecretIfUserExists() {
* OzgCloudElsterTransferConfigMapFactory.create(); when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
* when(remoteService.getConfigMap(anyString(),
* anyString())).thenReturn(configMap); service.updateConfigMapAndRestartDeploymentAndCreateSecret(namespace);
*
* service.delete(OzgCloudElsterTransferUserTestFactory.create()); verify(service, never()).createOrUpdateSecret(any(), any(), any());
* }
* verify(service).userExists(namespace, configMapNamespace, configMapName);
* @Nested
* } class TestUpdateConfigMapAndGenerateUserPassword {
*
* @Test void shouldNotCallUserExists() { @Test
* void shouldCallCreateOrGetConfigMap() {
* OzgCloudElsterTransferUser user = service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
* OzgCloudElsterTransferUserTestFactory.create();
* user.getSpec().setKeepAfterDelete(true); verify(service).createOrGetConfigMap(configMapNamespace, configMapName);
* }
* service.delete(user);
* @Test
* verify(service, never()).userExists(any(), any(), any()); void shouldCallGeneratePassword() {
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
* }
* verify(service).generatePassword();
* @Test void shouldCallDeleteUser() { configMap = }
* OzgCloudElsterTransferConfigMapFactory.create();
* when(remoteService.getConfigMap(anyString(), @Test
* anyString())).thenReturn(configMap); when(users.getUsersList()).thenReturn( void shouldCallAddUserToUserYaml() {
* OzgCloudElsterTransferConfigMapUserListFactory.create()); service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
* OzgCloudElsterTransferUser user = verify(service).addUserToUserYaml(any(), any(), any());
* OzgCloudElsterTransferUserTestFactory.create(); }
* when(service.userExists(namespace, configMapNamespace,
* configMapName)).thenReturn(true); @Test
* void shouldCallGetUsersFromConfigMap() {
* service.delete(user); when(service.createOrGetConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
*
* verify(service).deleteUser(user.getMetadata().getNamespace(), configMapName); service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
* }
* verify(service).getUsersFromConfigMap(configMap);
* @Test void shouldNotCallDeleteUserOrRestartDeploymentIfKeepAfterDelete() { }
* OzgCloudElsterTransferUser user =
* OzgCloudElsterTransferUserTestFactory.create(); @Test
* user.getSpec().setKeepAfterDelete(true); void shouldCallUpdateConfigMap() {
* String usersYaml = "usersYaml";
* service.delete(user); when(service.createOrGetConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
* when(service.generatePassword()).thenReturn(userPassword);
* verify(service, never()).deleteUser(any(), any()); verify(service, when(service.addUserToUserYaml(users, namespace, userPassword)).thenReturn(usersYaml);
* never()).restartDeployment(any(), any()); } when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
*
* @Test void shouldNotCallDeleteUserOrRestartDeploymentIfUserNotExists() { service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
* configMap = OzgCloudElsterTransferConfigMapFactory.create();
* when(remoteService.getConfigMap(anyString(), verify(service).updateConfigMap(configMapName, configMap, usersYaml);
* anyString())).thenReturn(configMap); OzgCloudElsterTransferUser user = }
* OzgCloudElsterTransferUserTestFactory.create();
* when(service.userExists(namespace, configMapNamespace, @Test
* configMapName)).thenReturn(false); void shouldReturnUserPassword() {
* when(service.generatePassword()).thenReturn(userPassword);
* service.delete(user);
* String result = service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, configMapName);
* verify(service, never()).deleteUser(any(), any()); verify(service,
* never()).restartDeployment(any(), any()); } assertThat(result).isEqualTo(userPassword);
* }
* @Test void shouldCallRestartDeployment() { configMap =
* OzgCloudElsterTransferConfigMapFactory.create(); @Nested
* when(remoteService.getConfigMap(anyString(), class TestCreateOrGetConfigMap {
* anyString())).thenReturn(configMap); when(users.getUsersList()).thenReturn(
* OzgCloudElsterTransferConfigMapUserListFactory.create()); @Test
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); void shouldCallGetConfigMap() {
* OzgCloudElsterTransferUser user = service.createOrGetConfigMap(configMapNamespace, configMapName);
* OzgCloudElsterTransferUserTestFactory.create();
* when(service.userExists(namespace, configMapNamespace, verify(service).getConfigMap(configMapNamespace, configMapName);
* configMapName)).thenReturn(true); }
*
* service.delete(user); @Test
* void shouldCallCreateConfigMap() {
* verify(service).restartDeployment(configMapNamespace, deploymentName); } } when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
*
* @Nested service.createOrGetConfigMap(configMapNamespace, configMapName);
*
* @DisplayName("updateConfigMapAndGenerateUserPassword") class verify(remoteService).createConfigMap(configMapNamespace, configMapName);
* TestupdateConfigMapAndGenerateUserPassword { }
*
* @BeforeEach public void setUp() { configMap = @Test
* OzgCloudElsterTransferConfigMapFactory.create(); void shouldCreateConfigMap() {
* when(remoteService.getConfigMap(anyString(), when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
* anyString())).thenReturn(configMap); } when(remoteService.createConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
*
* @Test void shouldNotCallCreateConfigMap() { ConfigMap result = service.createOrGetConfigMap(configMapNamespace, configMapName);
* when(remoteService.getConfigMap(configMapNamespace,
* configMapName)).thenReturn(configMap); assertThat(result).isEqualTo(configMap);
*
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, }
* configMapName);
* @Test
* verify(remoteService, never()).createConfigMap(any(), any()); } void shouldNotCallCreateConfigMap() {
* when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
* @Test void shouldCallGetConfigMap() {
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, service.createOrGetConfigMap(configMapNamespace, configMapName);
* configMapName);
* verify(remoteService, never()).createConfigMap(any(), any());
* verify(remoteService).getConfigMap(configMapNamespace, configMapName); } }
*
* @Test void shouldReturnGeneratedPassword() { String userPassword = @Nested
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, class TestGetConfigMap {
* configMapName);
* @Test
* assertNotNull(userPassword); } void shouldCallGetConfigMap() {
* service.getConfigMap(configMapNamespace, configMapName);
* @Test void shouldCallUpdateConfigMap() {
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, verify(remoteService).getConfigMap(configMapNamespace, configMapName);
* configMapName); }
*
* verify(service).updateConfigMap(eq(configMapNamespace), eq(configMapName), @Test
* eq(configMap), anyString()); } void shouldReturnConfigMap() {
* when(remoteService.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
* @Test void shouldNotCallUpdateConfigMap() {
* when(service.generatePassword()).thenReturn("psw"); ConfigMap result = service.getConfigMap(configMapNamespace, configMapName);
* when(service.addUserToUserYaml(namespace, configMap, "psw")).thenReturn("");
* assertThat(result).isEqualTo(configMap);
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, }
* configMapName);
* }
* verify(service, never()).updateConfigMap(any(), any(), any(), anyString()); }
* }
* @Test void shouldSetUserPSEmptyWWhenUserYamlEmpty() {
* when(service.generatePassword()).thenReturn("psw"); @Nested
* when(service.addUserToUserYaml(namespace, configMap, "psw")).thenReturn(""); class TestAddUserToUserYaml {
* @Test
* String userPassword = void shouldCallAddNewUserToList() {
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace, service.addUserToUserYaml(users, namespace, userPassword);
* configMapName);
* verify(service).addNewUserToList(eq(users), eq(namespace), anyString());
* assertTrue(userPassword.isEmpty()); } }
*
* @Test void shouldSetUserPSWWhenUserYamlNotEmpty() { @Test
* when(service.generatePassword()).thenReturn("psw"); void shouldCallConstructYamlEntries() {
* when(service.addUserToUserYaml(namespace, configMap, service.addUserToUserYaml(users, namespace, userPassword);
* "psw")).thenReturn("someYaml");
* verify(service).constructYamlEntries(users);
* String userPassword = }
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
* configMapName); @Test
* void shouldReturnUsersYaml() {
* assertFalse(userPassword.isEmpty()); } when(service.constructYamlEntries(users)).thenReturn("usersYaml");
*
* @Test void shouldCalladdUserToUserYaml() { String result = service.addUserToUserYaml(users, namespace, userPassword);
* service.updateConfigMapAndGenerateUserPassword(namespace, configMapNamespace,
* configMapName); assertThat(result).isEqualTo("usersYaml");
* }
* verify(service).addUserToUserYaml(eq(namespace), eq(configMap), anyString());
* } @Nested
* class TestAddNewUserToList {
* } @Test
* void shouldCallAddUserToList() {
* @Nested class addUserToUserYamlTests { service.addNewUserToList(users, namespace, "passwordHash");
*
* @Test void shouldCallgetUsersFromConfigMap() { configMap = verify(users).addUserToList(namespace, "passwordHash", Constants.USER_ROLE);
* OzgCloudElsterTransferConfigMapFactory.create();
* }
* service.addUserToUserYaml(namespace, configMap, "password"); }
*
* verify(service).getUsersFromConfigMap(configMap); } @Nested
* class TestConstructYamlEntries {
* @Test void shouldNotCallgetUsersFromConfigMap() { @Test
* service.addUserToUserYaml(namespace, null, "password"); void shouldCallGetUsersList() {
* service.constructYamlEntries(users);
* verify(service, never()).getUsersFromConfigMap(any()); }
* verify(users).getUsersList();
* @Test void shouldCallUserExistsInList() { configMap =
* OzgCloudElsterTransferConfigMapFactory.create(); }
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
* when(users.getUsersList()).thenReturn( @Test
* OzgCloudElsterTransferConfigMapUserListFactory.create()); void shouldHaveResultWithCorrectContentStart() {
* String result = service.constructYamlEntries(users);
* service.addUserToUserYaml(namespace, configMap, "password");
* assertTrue(result.startsWith("fileFormat: 1\nusers:\n"));
* verify(service).userExistsInList(users, namespace); } }
*
* @Test void shouldCallAddNewUserToListWhenUserNotExists() { configMap = @Test
* OzgCloudElsterTransferConfigMapFactory.create(); void shouldHaveResultWithCorrectContent() {
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); when(users.getUsersList()).thenReturn(
* OzgCloudElsterTransferConfigMapUserListFactory.create());
* service.addUserToUserYaml(namespace, configMap, "password"); String expectedYaml = "fileFormat: 1\n" + "users:\n" +
* " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }\n";
* verify(service).addNewUserToList(eq(users), eq(namespace), anyString()); }
* String result = service.constructYamlEntries(users);
* @Test void shouldCallconstructYamlEntries() { configMap =
* OzgCloudElsterTransferConfigMapFactory.create(); assertThat(expectedYaml).isEqualTo(result);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); }
*
* service.addUserToUserYaml(namespace, configMap, "password"); @Nested
* class TestGetYamlForUser {
* verify(service).constructYamlEntries(users); } @Test
* void shouldReturnExpectedYamlForUser() {
* @Test void TestUserYamlShouldNotBeEmpty() { configMap = Map<String, Object> userEntry = new HashMap<>();
* OzgCloudElsterTransferConfigMapFactory.create(); userEntry.put("login", "user1");
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); userEntry.put("rolle",
* "USER");
* userEntry.put("gruppe", "user1");
* String userYaml = service.addUserToUserYaml(namespace, configMap, Map<String, String> credentials = new HashMap<>();
* "password"); credentials.put("passwortHash",
* "$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a");
* assertFalse(userYaml.isEmpty()); } userEntry.put("credentials", credentials);
* String expectedYaml = " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }";
* @Test void TestUserYamlShouldBeEmpty() { configMap =
* OzgCloudElsterTransferConfigMapFactory.create(); String result = service.getYamlForUser(userEntry);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
* assertThat(expectedYaml).isEqualTo(result);
* }
* String userYaml = service.addUserToUserYaml(namespace, configMap,
* "password"); }
*
* assertTrue(userYaml.isEmpty()); } } }
*
* @Nested class UpdateConfigMapTests { }
*
* @Test void shouldCallCreateConfigMapIfConfigMapNotExists() { @Nested
* service.updateConfigMap(configMapName, null, "mockedUsersYaml"); class TestUpdateConfigMap {
* @Test
* verify(remoteService).createConfigMap(configMapNamespace, configMapName); } void shouldCallUpdateConfigMapData() {
* service.updateConfigMap(configMapName, configMap, "usersYaml");
* @Test void shouldNotCallCreateConfigMapIfConfigMapExists() {
* service.updateConfigMap(configMapName, configMap, "mockedUsersYaml"); verify(remoteService).updateConfigMapData(configMap, usersKey, "usersYaml");
* }
* verify(remoteService, never()).createConfigMap(any(), any()); } }
*
* @Test void shouldCallUpdateConfigMapData() { @Nested
* service.updateConfigMap(configMapName, configMap, "mockedUsersYaml"); class TestGetUsersFromConfigMap {
* @Test
* verify(remoteService).updateConfigMapData(configMap, usersKey, void shouldReturnEmptyUserList() {
* "mockedUsersYaml"); } ConfigMap configMap = new ConfigMap();
* configMap.setData(new HashMap<>());
* }
* OzgCloudElsterTransferConfigMapUserList result = service.getUsersFromConfigMap(configMap);
* @Nested class RestartDeploymentTests {
* assertThat(result.getUsersList()).isEmpty();
* @Test void shouldCallCreateConfigMap() { }
* service.restartDeployment(configMapNamespace, deploymentName);
* @Test
* verify(remoteService).restartDeployment(configMapNamespace, deploymentName); void shouldReturnEmptyUserListWhenUsersYamlIsEmpty() {
* } } ConfigMap configMap = new ConfigMap();
* Map<String, String> data = new HashMap<>();
* @Nested class UserExistsTests { data.put(usersKey, "");
* configMap.setData(data);
* @BeforeEach public void setUp() { configMap =
* OzgCloudElsterTransferConfigMapFactory.create(); OzgCloudElsterTransferConfigMapUserList result = service.getUsersFromConfigMap(configMap);
* when(remoteService.getConfigMap(configMapNamespace,
* configMapName)).thenReturn(configMap); } assertNotNull(result);
* assertThat(result.getUsersList()).isEmpty();
* @Test void shouldCallGetConfigMap() { service.userExists(namespace, }
* configMapNamespace, configMapName);
* void shouldReturnParsedUserListWhenUsersYamlIsValid() {
* verify(remoteService).getConfigMap(configMapNamespace, configMapName); } ConfigMap configMap = OzgCloudElsterTransferConfigMapFactory.create();
*
* @Test void shouldReturnUserExistsTrueIfUserExists() { OzgCloudElsterTransferConfigMapUserList result = service.getUsersFromConfigMap(configMap);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); Map<String, Object> user1 = result.getUsersList().get(0);
* when(users.existsUser(namespace)).thenReturn(true);
* assertThat(result.getUsersList()).hasSize(1);
* boolean userExists = service.userExists(namespace, configMapNamespace, assertThat(user1.get("login")).isEqualTo("admin");
* configMapName); assertThat(user1.get("role")).isEqualTo("ADMIN");
* assertThat(user1.get("passwordHash")).isEqualTo("$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a");
* assertTrue(userExists); } assertThat(user1.get("group")).isEqualTo("Administratoren");
* }
* @Test void shouldReturnUserExistsTrueIfUserNotExists() { boolean userExists =
* service.userExists(namespace, configMapNamespace, configMapName); }
*
* assertFalse(userExists); } }
*
* @Test void shouldCallgetUsersFromConfigMap() { service.userExists(namespace, @Nested
* configMapNamespace, configMapName); class TestRestartDeployment {
*
* verify(service).getUsersFromConfigMap(configMap); } @Test
* void shouldCallRestartDeployment() {
* @Test void shouldCallExistsUser() { service.restartDeployment(configMapNamespace, deploymentName);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
* verify(remoteService).restartDeployment(configMapNamespace, deploymentName);
* service.userExists(namespace, configMapNamespace, configMapName); }
*
* verify(users).existsUser(namespace); } }
*
* } @Nested
* class TestCreateOrUpdateSecret {
* @Nested class DeleteUserTests {
* @Test
* @BeforeEach public void setUp() { configMap = void shouldCallRestartDeployment() {
* OzgCloudElsterTransferConfigMapFactory.create(); service.createOrUpdateSecret(namespace, userPassword, secretName);
* when(remoteService.getConfigMap(configMapNamespace,
* configMapName)).thenReturn(configMap); } verify(remoteService).createOrUpdateSecret(namespace, userPassword, secretName);
* }
* @Test void shouldCallGetConfigMap() { service.deleteUser(namespace,
* configMapName); }
*
* verify(remoteService).getConfigMap(configMapNamespace, configMapName); } }
*
* @Test void shouldCallGetUsersFromConfigMap() { service.deleteUser(namespace, @Nested
* configMapName); class TestDelete {
*
* verify(service).getUsersFromConfigMap(configMap); } @BeforeEach
* void setUp() {
* @Test void shouldCallremoveDeleted() { ReflectionTestUtils.setField(service, "etrNamespace", "elster-transfer");
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); }
*
* service.deleteUser(namespace, configMapName); @Test
* void shouldCallUserExists() {
* verify(users).removeDeleted(namespace); } service.delete(OzgCloudElsterTransferUserTestFactory.create());
*
* @Test void ShouldCallConstructYamlEntries() { verify(service).userExists(namespace, configMapNamespace, configMapName);
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); }
*
* service.deleteUser(namespace, configMapName); @Test
* void shouldCallDeleteUser() {
* verify(service).constructYamlEntries(users); } when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
* configMap = OzgCloudElsterTransferConfigMapFactory.create();
* @Test void ShouldCallUpdateConfigMapData() { when(remoteService.getConfigMap(anyString(),
* when(service.getUsersFromConfigMap(configMap)).thenReturn(users); anyString())).thenReturn(configMap);
* when(service.constructYamlEntries(users)).thenReturn("updatedUsersYaml");
* service.delete(OzgCloudElsterTransferUserTestFactory.create());
* service.deleteUser(namespace, configMapName);
* verify(service).deleteUser(namespace, configMapNamespace);
* verify(remoteService).updateConfigMapData(configMap, usersKey, }
* "updatedUsersYaml"); } }
* @Test
* @Nested class CreateOrUpdateSecretTests { void shouldCallRestartDeployment() {
* when(service.userExists(namespace, configMapNamespace, configMapName)).thenReturn(true);
* @Test void shouldCallCreateOrUpdateSecret() { configMap = OzgCloudElsterTransferConfigMapFactory.create();
* service.createOrUpdateSecret(namespace, "psw", secretName); when(remoteService.getConfigMap(anyString(),
* anyString())).thenReturn(configMap);
* verify(remoteService).createOrUpdateSecret(namespace, "psw", secretName); }
* service.delete(OzgCloudElsterTransferUserTestFactory.create());
* }
* verify(service).restartDeployment(configMapNamespace, deploymentName);
* @Nested class GetUsersFromConfigMapTests { }
*
* @BeforeEach public void setUp() { configMap = @Test
* OzgCloudElsterTransferConfigMapFactory.create(); } void shouldNotCallRestartDeploymentIfUserNotExists() {
* service.delete(OzgCloudElsterTransferUserTestFactory.create());
* @Test void shouldReturnObjectConfigMapUserList() {
* OzgCloudElsterTransferConfigMapUserList result = verify(service, never()).restartDeployment(any(), any());
* service.getUsersFromConfigMap(configMap); }
*
* assertNotNull(result); @Test
* assertInstanceOf(OzgCloudElsterTransferConfigMapUserList.class, result); } void shouldNotCallDeleteUserIfUserNotExists() {
* service.delete(OzgCloudElsterTransferUserTestFactory.create());
* @Test void shouldReturnConfigMapUserListWithContent() {
* OzgCloudElsterTransferConfigMapUserList result = verify(service, never()).deleteUser(any(), any());
* service.getUsersFromConfigMap(configMap); }
*
* List<Map<String, Object>> usersList = result.getUsersList(); @Nested
* class TestUserExists {
* assertThat(usersList).hasSize(1); }
* @Test
* } void shouldCallGetConfigMap() {
* service.userExists(namespace, configMapNamespace, configMapName);
* @Nested class UserExistsInListTests {
* verify(service).getConfigMap(configMapNamespace, configMapName);
* @Test void shouldCallExistsUser() { service.userExistsInList(users, }
* namespace);
* @Test
* verify(users).existsUser(namespace); } void shouldCallGetUsersFromConfigMap() {
* when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
* }
* service.userExists(namespace, configMapNamespace, configMapName);
* @Nested class AddNewUserToListTests {
* verify(service).getUsersFromConfigMap(configMap);
* @Test void shouldCallAddUserToList() { service.addNewUserToList(users, }
* namespace, "pswHash");
* @Test
* verify(users).addUserToList(namespace, "pswHash", "USER"); } void shouldNotCallGetUsersFromConfigMap() {
* when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
* }
* service.userExists(namespace, configMapNamespace, configMapName);
* @Nested class ConstructYamlEntriesTests {
* verify(service, never()).getUsersFromConfigMap(any());
* @Test void shouldHaveResultWithCorrectContentStart() { String result = }
* service.constructYamlEntries(users);
* @Test
* assertTrue(result.startsWith("fileFormat: 1\nusers:\n")); } void shouldCallExistsUser() {
* when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(configMap);
* @Test void shouldHaveResultWithCorrectContent() { when(service.getUsersFromConfigMap(configMap)).thenReturn(users);
* when(users.getUsersList()).thenReturn(
* OzgCloudElsterTransferConfigMapUserListFactory.create()); String expectedYaml service.userExists(namespace, configMapNamespace, configMapName);
* = "fileFormat: 1\n" + "users:\n" +
* " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }\n" verify(users, times(2)).existsUser(namespace);
* ; }
*
* String result = service.constructYamlEntries(users); @Test
* void shouldNotCallExistsUser() {
* assertThat(expectedYaml).isEqualTo(result); } } when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
*
* @Nested class GetYamlForUserTests { service.userExists(namespace, configMapNamespace, configMapName);
*
* @Test void shouldReturnExpectedYamlForUser() { Map<String, Object> userEntry verify(users, never()).existsUser(any());
* = new HashMap<>(); userEntry.put("login", "user1"); userEntry.put("rolle", }
* "USER"); userEntry.put("gruppe", "user1"); Map<String, String> credentials =
* new HashMap<>(); credentials.put("passwortHash", @Test
* "$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a"); void shouldReturnFalseWhenConfigMapNotExists() {
* userEntry.put("credentials", credentials); String expectedYaml = when(service.getConfigMap(configMapNamespace, configMapName)).thenReturn(null);
* " - { login: \"user1\", rolle: \"USER\", credentials: { passwortHash: \"$2a$12$cqKZMcwTUe/tju7PIFGhperWdV2Xa9o4fVw5eClbzatRhvxZphE1a\" }, gruppe: \"user1\" }\n"
* ; boolean result = service.userExists(namespace, configMapNamespace, configMapName);
*
* String result = service.getYamlForUser(userEntry); assertThat(result).isFalse();
* }
* assertThat(expectedYaml).isEqualTo(result); }
* @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
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment