Skip to content
Snippets Groups Projects
Commit 893c5b1e authored by OZGCloud's avatar OZGCloud
Browse files

OZG-3961 OZG-4082 cleanup

parent 29340382
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
src/main/java/de/ozgcloud/operator/keycloak/user/KeycloakUserRemoteService.java
+ 61
− 39
View file @ 893c5b1e
...@@ -29,6 +29,8 @@ import java.util.Objects; ...@@ -29,6 +29,8 @@ import java.util.Objects;
import java.util.Optional; import java.util.Optional;
import java.util.logging.Level; import java.util.logging.Level;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.keycloak.admin.client.CreatedResponseUtil; import org.keycloak.admin.client.CreatedResponseUtil;
import org.keycloak.admin.client.Keycloak; import org.keycloak.admin.client.Keycloak;
import org.keycloak.admin.client.resource.RealmResource; import org.keycloak.admin.client.resource.RealmResource;
...@@ -41,6 +43,7 @@ import org.springframework.stereotype.Component; ...@@ -41,6 +43,7 @@ import org.springframework.stereotype.Component;
import de.ozgcloud.operator.keycloak.KeycloakException; import de.ozgcloud.operator.keycloak.KeycloakException;
import de.ozgcloud.operator.keycloak.KeycloakGenericRemoteService; import de.ozgcloud.operator.keycloak.KeycloakGenericRemoteService;
import de.ozgcloud.operator.keycloak.KeycloakResultParser; import de.ozgcloud.operator.keycloak.KeycloakResultParser;
import de.ozgcloud.operator.keycloak.user.OzgKeycloakUserSpec.KeycloakUserSpecUser;
import io.fabric8.kubernetes.api.model.ObjectMeta; import io.fabric8.kubernetes.api.model.ObjectMeta;
import io.fabric8.kubernetes.api.model.Secret; import io.fabric8.kubernetes.api.model.Secret;
import io.fabric8.kubernetes.api.model.SecretBuilder; import io.fabric8.kubernetes.api.model.SecretBuilder;
...@@ -52,8 +55,9 @@ import lombok.extern.java.Log; ...@@ -52,8 +55,9 @@ import lombok.extern.java.Log;
@Component @Component
class KeycloakUserRemoteService { class KeycloakUserRemoteService {
private static final String SECRET_PASSWORD_FIELD = "password"; private static final String SECRET_TYPE = "Opaque";
private static final String SECRET_NAME_FIELD = "name"; static final String SECRET_PASSWORD_FIELD = "password";
static final String SECRET_NAME_FIELD = "name";
@Autowired @Autowired
private Keycloak keycloak; private Keycloak keycloak;
...@@ -115,57 +119,75 @@ class KeycloakUserRemoteService { ...@@ -115,57 +119,75 @@ class KeycloakUserRemoteService {
realmResource.users().get(userId).roles().clientLevel(appClient.getId()).add(Arrays.asList(clientRole)); realmResource.users().get(userId).roles().clientLevel(appClient.getId()).add(Arrays.asList(clientRole));
} }
// PoC public boolean existSecret(OzgKeycloakUserSpec userSpec, String namespace) {
public String createSecret(OzgKeycloakUserSpec userSpec, String createdNamespace) { var secret = getUserSecret(userSpec, namespace);
return Objects.nonNull(secret.get());
}
public void createSecret(OzgKeycloakUserSpec userSpec, String createdNamespace) {
log.log(Level.INFO, "Create secret for user: " + userSpec.getKeycloakUser().getUsername()); log.log(Level.INFO, "Create secret for user: " + userSpec.getKeycloakUser().getUsername());
var secretName = userSpec.getKeycloakUser().getUsername().toLowerCase() + "-credentials"; var namespace = "keycloak";// TODO durch den namespace ersetzen, wenn die Helm Charts passen
// var namespace = "keycloak"; var credentialsSecret = createUserSecret(userSpec.getKeycloakUser(), namespace);
var namespace = createdNamespace;
var secret = getSecret(secretName, namespace);
if (Objects.isNull(secret.get())) {
log.log(Level.INFO, "...secret does not exist, create one...");
var credentialsSecret = buildSecret(secretName, userSpec.getKeycloakUser().getPassword());
kubernetesClient.secrets().inNamespace(namespace).create(credentialsSecret); kubernetesClient.secrets().inNamespace(namespace).create(credentialsSecret);
log.log(Level.INFO, "Secret successful created in namespace: " + namespace);
log.log(Level.INFO, "...secret created '" + secretName + "' in " + namespace + " for user " + userSpec.getKeycloakUser().getUsername());
var newPassword = getPassword(getSecret(secretName, namespace));
log.log(Level.INFO, "return password from created secret:" + newPassword);
return newPassword;
}
var password = getPassword(secret);
log.log(Level.INFO, "secret exists, return with password:" + password);
return password;
} }
private Resource<Secret> getSecret(String secretName, String namespace) { Secret createUserSecret(KeycloakUserSpecUser userSpec, String namespace) {
return kubernetesClient.secrets().inNamespace(namespace).withName(secretName); return new SecretBuilder()
.withType(SECRET_TYPE)
.withMetadata(createMetaData(userSpec, namespace))
.addToStringData(SECRET_NAME_FIELD, userSpec.getUsername())
.addToStringData(SECRET_PASSWORD_FIELD, getPassword(userSpec.getPassword()))
.build();
} }
Secret buildSecret(String name, String password) { private ObjectMeta createMetaData(KeycloakUserSpecUser userSpec, String namespace) {
var name = buildCredentialSecretName(userSpec);
var metadata = new ObjectMeta(); var metadata = new ObjectMeta();
// TOCHECK welchen Namen brauchen wir?
metadata.setName(name); metadata.setName(name);
metadata.setGenerateName(name); metadata.setGenerateName(name);
metadata.setNamespace("keycloak"); //
metadata.setNamespace(namespace);
return metadata;
}
return new SecretBuilder() String getPassword(String userPassword) {
.withType("Opaque") return StringUtils.isEmpty(userPassword) ? generateRandomPasswordForKeycloak() : userPassword;
.withMetadata(metadata)
.addToStringData(SECRET_PASSWORD_FIELD, password)
.addToStringData(SECRET_NAME_FIELD, name)
.build();
} }
private String getPassword(Resource<Secret> secret) { private String generateRandomPasswordForKeycloak() {
return decodeBase64(secret.get().getData().get(SECRET_PASSWORD_FIELD)); var upperCaseCharacter = RandomStringUtils.random(1).toUpperCase();
var randomString = RandomStringUtils.random(7);
return upperCaseCharacter + randomString;
} }
String decodeBase64(String base64String) { public String getPasswordFromSecret(OzgKeycloakUserSpec userSpec, String namespace) {
log.log(Level.INFO, "base64String to decode: " + base64String); var secret = getUserSecret(userSpec, namespace);
var decoded = Base64.getDecoder().decode(base64String); return getPasswordFromSecret(secret);
log.log(Level.INFO, "decoded string: " + decoded); }
return new String(decoded);
public Resource<Secret> getUserSecret(OzgKeycloakUserSpec userSpec, String namespace) {
var secretName = buildCredentialSecretName(userSpec.getKeycloakUser());
return getUserSecret(secretName, namespace);
}
private String buildCredentialSecretName(KeycloakUserSpecUser userSpec) {
return userSpec.getUsername().toLowerCase() + "-credentials";
}
private Resource<Secret> getUserSecret(String secretName, String namespace) {
return kubernetesClient.secrets().inNamespace(namespace).withName(secretName);
}
private String getPasswordFromSecret(Resource<Secret> secret) {
return decodeBase64(secret.get().getStringData().get(SECRET_PASSWORD_FIELD));
}
private String decodeBase64(String base64String) {
return new String(Base64.getDecoder().decode(base64String));
} }
//
} }
\ No newline at end of file
src/main/java/de/ozgcloud/operator/keycloak/user/KeycloakUserService.java
+ 9
− 10
View file @ 893c5b1e
...@@ -42,17 +42,16 @@ class KeycloakUserService { ...@@ -42,17 +42,16 @@ class KeycloakUserService {
private KeycloakUserMapper userMapper; private KeycloakUserMapper userMapper;
public void createOrUpdateUser(OzgKeycloakUserSpec userSpec, String namespace) { public void createOrUpdateUser(OzgKeycloakUserSpec userSpec, String namespace) {
// PoC log.log(Level.INFO, "createOrUpdateUser");
// if (!StringUtils.hasLength(userSpec.getKeycloakUser().getPassword())) {
log.log(Level.INFO, "createOrUpdateUser createSecret for credentials..."); if (!remoteService.existSecret(userSpec, namespace)) {
log.log(Level.INFO, "Old password: " + userSpec.getKeycloakUser().getPassword()); log.log(Level.INFO, "Secret not exists -> create one");
// log.log(Level.INFO, "User has no password, create secret..."); remoteService.createSecret(userSpec, namespace);
var password = remoteService.createSecret(userSpec, namespace); }
log.log(Level.INFO, "New password: " + password); var password = remoteService.getPasswordFromSecret(userSpec, namespace);
log.log(Level.INFO, "Update password to: " + password);
userSpec.getKeycloakUser().setPassword(password); userSpec.getKeycloakUser().setPassword(password);
// }
log.log(Level.INFO, "proceed");
//
remoteService.getUserByName(userSpec.getKeycloakUser().getUsername(), namespace) remoteService.getUserByName(userSpec.getKeycloakUser().getUsername(), namespace)
.ifPresentOrElse(existingUser -> remoteService.updateUser(userMapper.update(existingUser, userSpec), namespace), .ifPresentOrElse(existingUser -> remoteService.updateUser(userMapper.update(existingUser, userSpec), namespace),
() -> remoteService.createUser(userMapper.map(userSpec), namespace)); () -> remoteService.createUser(userMapper.map(userSpec), namespace));
......
src/test/java/de/ozgcloud/operator/keycloak/user/KeycloakUserRemoteServiceTest.java
+ 195
− 0
View file @ 893c5b1e
...@@ -28,12 +28,14 @@ import static org.junit.jupiter.api.Assertions.*; ...@@ -28,12 +28,14 @@ import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*; import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
import java.util.Base64;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Nested;
...@@ -54,7 +56,13 @@ import org.mockito.Spy; ...@@ -54,7 +56,13 @@ import org.mockito.Spy;
import de.ozgcloud.operator.keycloak.KeycloakException; import de.ozgcloud.operator.keycloak.KeycloakException;
import de.ozgcloud.operator.keycloak.KeycloakGenericRemoteService; import de.ozgcloud.operator.keycloak.KeycloakGenericRemoteService;
import de.ozgcloud.operator.keycloak.user.OzgKeycloakUserSpec.KeycloakUserSpecUser;
import io.fabric8.kubernetes.api.model.Secret;
import io.fabric8.kubernetes.api.model.SecretBuilder;
import io.fabric8.kubernetes.api.model.SecretList;
import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.KubernetesClient;
import io.fabric8.kubernetes.client.dsl.MixedOperation;
import io.fabric8.kubernetes.client.dsl.Resource;
class KeycloakUserRemoteServiceTest { class KeycloakUserRemoteServiceTest {
...@@ -272,4 +280,191 @@ class KeycloakUserRemoteServiceTest { ...@@ -272,4 +280,191 @@ class KeycloakUserRemoteServiceTest {
verify(usersResource).delete(USERID); verify(usersResource).delete(USERID);
} }
} }
@DisplayName("Exists secret")
@Nested
class TestExistsSecret {
private final OzgKeycloakUserSpec userSpec = OzgKeycloakUserSpecTestFactory.create();
@Mock
private Resource<Secret> resourceMock;
@BeforeEach
void mock() {
doReturn(resourceMock).when(userRemoteService).getUserSecret(any(), any());
}
@Test
void shouldReturnTrueIfExists() {
when(resourceMock.get()).thenReturn(new Secret());
var exists = userRemoteService.existSecret(userSpec, REALM);
assertThat(exists).isTrue();
}
@Test
void shouldReturnFalseIfNotExists() {
when(resourceMock.get()).thenReturn(null);
var exists = userRemoteService.existSecret(userSpec, REALM);
assertThat(exists).isFalse();
}
}
@DisplayName("Create Secret")
@Nested
class TestCreateSecret {
private final OzgKeycloakUserSpec userSpec = OzgKeycloakUserSpecTestFactory.create();
@Mock
private Secret credentialSecret;
@Mock
private MixedOperation<Secret, SecretList, Resource<Secret>> secretsMock;
@BeforeEach
void mock() {
when(kubernetesClient.secrets()).thenReturn(secretsMock);
when(secretsMock.inNamespace(any())).thenReturn(secretsMock);
}
@Test
void shouldBuildUserSecret() {
userRemoteService.createSecret(userSpec, REALM);
verify(userRemoteService).createUserSecret(eq(userSpec.getKeycloakUser()), any());
}
@Test
void shouldCreateSecret() {
userRemoteService.createSecret(userSpec, REALM);
verify(secretsMock).create(any());
}
}
@DisplayName("Create user secret")
@Nested
class TestCreateUserSecret {
private final KeycloakUserSpecUser userSpec = KeycloakUserSpecUserTestFactory.create();
@Test
void shouldHaveType() {
var secret = userRemoteService.createUserSecret(userSpec, REALM);
assertThat(secret.getType()).isEqualTo("Opaque");
}
@Test
void shouldHaveUserName() {
var secret = userRemoteService.createUserSecret(userSpec, REALM);
assertThat(secret.getStringData()).containsEntry(KeycloakUserRemoteService.SECRET_NAME_FIELD, KeycloakUserSpecUserTestFactory.USERNAME);
}
@Test
void shouldHavePassword() {
doReturn(KeycloakUserSpecUserTestFactory.PASSWORD).when(userRemoteService).getPassword(any());
var secret = userRemoteService.createUserSecret(userSpec, REALM);
assertThat(secret.getStringData()).containsEntry(KeycloakUserRemoteService.SECRET_PASSWORD_FIELD,
KeycloakUserSpecUserTestFactory.PASSWORD);
}
@DisplayName("metadata")
@Nested
class TestMetaData {
@Test
void shouldHaveName() {
var secret = userRemoteService.createUserSecret(userSpec, REALM);
assertThat(secret.getMetadata().getName()).isEqualTo(userSpec.getUsername() + "-credentials");
}
@Test
void shouldHaveGeneratedName() {
var secret = userRemoteService.createUserSecret(userSpec, REALM);
assertThat(secret.getMetadata().getGenerateName()).isEqualTo(userSpec.getUsername() + "-credentials");
}
@Test
void shouldHaveNamespace() {
var secret = userRemoteService.createUserSecret(userSpec, REALM);
assertThat(secret.getMetadata().getNamespace()).isEqualTo(REALM);
}
}
}
@DisplayName("Get password")
@Nested
class TestGetPassword {
@Test
void shouldReturnPasswordIfExists() {
var password = userRemoteService.getPassword(KeycloakUserSpecUserTestFactory.PASSWORD);
assertThat(password).isEqualTo(KeycloakUserSpecUserTestFactory.PASSWORD);
}
@Test
void shouldGeneratePasswordIfNotExists() {
var password = userRemoteService.getPassword(StringUtils.EMPTY);
assertThat(password).isNotEmpty();
assertThat(StringUtils.substring(password, 0, 1)).isUpperCase();
}
}
@DisplayName("Get user secret")
@Nested
class TestGetUserSecret {
@Mock
private MixedOperation<Secret, SecretList, Resource<Secret>> secretsMock;
@BeforeEach
void mock() {
when(kubernetesClient.secrets()).thenReturn(secretsMock);
when(secretsMock.inNamespace(any())).thenReturn(secretsMock);
}
@Test
void shouldGetWithName() {
userRemoteService.getUserSecret(OzgKeycloakUserSpecTestFactory.create(), REALM);
verify(secretsMock).withName(KeycloakUserSpecUserTestFactory.USERNAME + "-credentials");
}
}
@DisplayName("Get password from secret")
@Nested
class TestGetPasswordFromSecret {
@Mock
private Resource<Secret> resource;
private OzgKeycloakUserSpec userSpec = OzgKeycloakUserSpecTestFactory.create();
private Secret secret = new SecretBuilder()
.addToStringData(KeycloakUserRemoteService.SECRET_PASSWORD_FIELD, Base64.getEncoder().encodeToString("dummyPassword".getBytes()))
.build();
@Test
void shouldReturnDecodedPassword() {
doReturn(resource).when(userRemoteService).getUserSecret(any(), any());
when(resource.get()).thenReturn(secret);
var password = userRemoteService.getPasswordFromSecret(userSpec, REALM);
assertThat(password).isEqualTo("dummyPassword");
}
}
} }
\ No newline at end of file
src/test/java/de/ozgcloud/operator/keycloak/user/KeycloakUserServiceTest.java
+ 74
− 31
View file @ 893c5b1e
...@@ -23,88 +23,131 @@ ...@@ -23,88 +23,131 @@
*/ */
package de.ozgcloud.operator.keycloak.user; package de.ozgcloud.operator.keycloak.user;
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.*;
import java.util.Optional; import java.util.Optional;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
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.keycloak.representations.idm.UserRepresentation; import org.keycloak.representations.idm.UserRepresentation;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy; import org.mockito.Spy;
import io.fabric8.kubernetes.api.model.Secret;
import io.fabric8.kubernetes.client.dsl.Resource;
class KeycloakUserServiceTest { class KeycloakUserServiceTest {
private static final String TEST_NAMESPACE = "TestNamespace"; private static final String TEST_NAMESPACE = "TestNamespace";
private static final String TEST_USERID = "TestUserId"; private static final String TEST_USERID = "TestUserId";
private static final String PASSWORD = "CreatedDummyPassword";
@Spy @Spy
@InjectMocks @InjectMocks
private KeycloakUserService userService; private KeycloakUserService service;
@Mock @Mock
private KeycloakUserRemoteService userRemoteService; private KeycloakUserRemoteService remoteService;
@Mock @Mock
private KeycloakUserMapper userMapper; private KeycloakUserMapper userMapper;
@DisplayName("Create or Update")
@Nested @Nested
class TestAddUser { class TestCreateOrUpdate {
@Test @Mock
void shouldCallUserMapper() { private Resource<Secret> resource;
var testUser = OzgKeycloakUserSpecTestFactory.create(); @Captor
private ArgumentCaptor<OzgKeycloakUserSpec> ozgKeycloakUserSpecCaptor;
userService.createOrUpdateUser(testUser, TEST_NAMESPACE); private final OzgKeycloakUserSpec userSpec = OzgKeycloakUserSpecTestFactory.create();
verify(userMapper).map(testUser); @BeforeEach
void mock() {
when(remoteService.getPasswordFromSecret(any(), any())).thenReturn(PASSWORD);
} }
@Test @Test
void shouldCallUserRemoteServiceGetUserByName() { void shouldVerifiySecretExists() {
var userRepresentation = UserRepresentationTestFactory.create(); service.createOrUpdateUser(userSpec, TEST_NAMESPACE);
verify(remoteService).existSecret(userSpec, TEST_NAMESPACE);
}
userService.createOrUpdateUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE); @Test
void shouldCreateSecretIfNotExists() {
when(remoteService.existSecret(any(), any())).thenReturn(false);
verify(userRemoteService).getUserByName(eq(userRepresentation.getUsername()), eq(TEST_NAMESPACE)); service.createOrUpdateUser(userSpec, TEST_NAMESPACE);
verify(remoteService).createSecret(userSpec, TEST_NAMESPACE);
} }
@Test @Test
void shouldCreateSecretIfPasswordIsNotSet() { void shouldGetPasswordFromSecret() {
when(userRemoteService.createSecret(any(), any())).thenReturn("TestPassword"); service.createOrUpdateUser(userSpec, TEST_NAMESPACE);
verify(remoteService).getPasswordFromSecret(userSpec, TEST_NAMESPACE);
}
var testUser = OzgKeycloakUserSpecTestFactory.createBuilder() @Test
void shouldSetPasswortFromSecret() {
var userWithoutPassword = OzgKeycloakUserSpecTestFactory.createBuilder()
.keycloakUser(KeycloakUserSpecUserTestFactory.createBuiler().password(StringUtils.EMPTY).build()).build(); .keycloakUser(KeycloakUserSpecUserTestFactory.createBuiler().password(StringUtils.EMPTY).build()).build();
userService.createOrUpdateUser(testUser, TEST_NAMESPACE); service.createOrUpdateUser(userWithoutPassword, TEST_NAMESPACE);
verify(userMapper).map(ozgKeycloakUserSpecCaptor.capture());
assertThat(ozgKeycloakUserSpecCaptor.getValue().getKeycloakUser().getPassword()).isEqualTo(PASSWORD);
}
@Test
void shouldCallUserMapper() {
service.createOrUpdateUser(userSpec, TEST_NAMESPACE);
verify(userMapper).map(userSpec);
}
@Test
void shouldCallUserRemoteServiceGetUserByName() {
var userRepresentation = UserRepresentationTestFactory.create();
service.createOrUpdateUser(userSpec, TEST_NAMESPACE);
verify(userRemoteService).createSecret(testUser, TEST_NAMESPACE); verify(remoteService).getUserByName(userRepresentation.getUsername(), TEST_NAMESPACE);
} }
@Test @Test
void shouldCreateUserIfNotExists() { void shouldCreateUserIfNotExists() {
when(userRemoteService.getUserByName(OzgKeycloakUserSpecTestFactory.KEYCLOAK_USER.getUsername(), TEST_NAMESPACE)) when(remoteService.getUserByName(OzgKeycloakUserSpecTestFactory.KEYCLOAK_USER.getUsername(), TEST_NAMESPACE))
.thenReturn(Optional.empty()); .thenReturn(Optional.empty());
when(userMapper.map(any())).thenReturn(mock(UserRepresentation.class)); when(userMapper.map(any())).thenReturn(Mockito.mock(UserRepresentation.class));
userService.createOrUpdateUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE); service.createOrUpdateUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE);
verify(userRemoteService).createUser(any(UserRepresentation.class), eq(TEST_NAMESPACE)); verify(remoteService).createUser(any(UserRepresentation.class), eq(TEST_NAMESPACE));
} }
@Test @Test
void shouldUpdateUserIfExists() { void shouldUpdateUserIfExists() {
var userRepresentation = mock(UserRepresentation.class); var userRepresentation = Mockito.mock(UserRepresentation.class);
when(userRemoteService.getUserByName(OzgKeycloakUserSpecTestFactory.KEYCLOAK_USER.getUsername(), TEST_NAMESPACE)) when(remoteService.getUserByName(OzgKeycloakUserSpecTestFactory.KEYCLOAK_USER.getUsername(), TEST_NAMESPACE))
.thenReturn(Optional.of(userRepresentation)); .thenReturn(Optional.of(userRepresentation));
when(userMapper.update(eq(userRepresentation), any())).thenReturn(userRepresentation); when(userMapper.update(eq(userRepresentation), any())).thenReturn(userRepresentation);
userService.createOrUpdateUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE); service.createOrUpdateUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE);
verify(userRemoteService).updateUser(eq(userRepresentation), eq(TEST_NAMESPACE)); verify(remoteService).updateUser(userRepresentation, TEST_NAMESPACE);
} }
} }
...@@ -116,7 +159,7 @@ class KeycloakUserServiceTest { ...@@ -116,7 +159,7 @@ class KeycloakUserServiceTest {
var testUser = OzgKeycloakUserSpecTestFactory.create(); var testUser = OzgKeycloakUserSpecTestFactory.create();
userService.deleteUser(testUser, TEST_NAMESPACE); service.deleteUser(testUser, TEST_NAMESPACE);
verify(userMapper).map(testUser); verify(userMapper).map(testUser);
} }
...@@ -127,9 +170,9 @@ class KeycloakUserServiceTest { ...@@ -127,9 +170,9 @@ class KeycloakUserServiceTest {
var userRepresentation = UserRepresentationTestFactory.create(); var userRepresentation = UserRepresentationTestFactory.create();
when(userMapper.map(any())).thenReturn(userRepresentation); when(userMapper.map(any())).thenReturn(userRepresentation);
userService.deleteUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE); service.deleteUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE);
verify(userRemoteService).getUserByName(eq(userRepresentation.getUsername()), eq(TEST_NAMESPACE)); verify(remoteService).getUserByName(userRepresentation.getUsername(), TEST_NAMESPACE);
} }
@Test @Test
...@@ -137,12 +180,12 @@ class KeycloakUserServiceTest { ...@@ -137,12 +180,12 @@ class KeycloakUserServiceTest {
var userRepresentation = UserRepresentationTestFactory.create(); var userRepresentation = UserRepresentationTestFactory.create();
when(userMapper.map(any())).thenReturn(userRepresentation); when(userMapper.map(any())).thenReturn(userRepresentation);
when(userRemoteService.getUserByName(UserRepresentationTestFactory.USERNAME, TEST_NAMESPACE)).thenReturn(Optional.of(userRepresentation)); when(remoteService.getUserByName(UserRepresentationTestFactory.USERNAME, TEST_NAMESPACE)).thenReturn(Optional.of(userRepresentation));
userRepresentation.setId(TEST_USERID); userRepresentation.setId(TEST_USERID);
userService.deleteUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE); service.deleteUser(OzgKeycloakUserSpecTestFactory.create(), TEST_NAMESPACE);
verify(userRemoteService).deleteUser(eq(TEST_USERID), eq(TEST_NAMESPACE)); verify(remoteService).deleteUser(TEST_USERID, TEST_NAMESPACE);
} }
} }
} }
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

Impressum - Datenschutz - Barrierefreiheit