OZG-5400 clean code and add unittests for realm update

ozgcloud-keycloak-operator/src/main/java/de/ozgcloud/operator/keycloak/realm/KeycloakRealmMapper.java

@@ -35,21 +35,23 @@ import org.mapstruct.MappingTarget;
 import org.mapstruct.Named;
 import org.mapstruct.ReportingPolicy;
 
+import de.ozgcloud.operator.keycloak.realm.OzgCloudKeycloakRealmSpec.KeycloakRealmSMTPServer;
+
 @Mapper(unmappedTargetPolicy = ReportingPolicy.IGNORE, unmappedSourcePolicy = ReportingPolicy.IGNORE)
 interface KeycloakRealmMapper {
 
 	public static final String ACTION_TOKEN_GENERATED_BY_USER_LIFE_SPAN = "900";
 	public static final String PASSWORD_POLICY = "upperCase(1) and lowerCase(1) and length(8) and notUsername";
-	public static final String  DEFAULT_LOCAL = "de";
+	public static final String  DEFAULT_LOCALE = "de";
 	public static final String RESET_PASSWORD_ALLOWED = "true";
 	public static final String ENABLED = "true";
 	public static final String INTERNATIONALIZATION_ENABLED = "true";
 
-	@Mapping(target = "displayName", source = "displayName")
+	
 	@Mapping(target = "enabled", constant = ENABLED)
 	@Mapping(target = "resetPasswordAllowed", constant = RESET_PASSWORD_ALLOWED)
 	@Mapping(target = "supportedLocales", source = ".", qualifiedByName = "supportedLocales")
-	@Mapping(target = "defaultLocale", constant = DEFAULT_LOCAL)
+	@Mapping(target = "defaultLocale", constant = DEFAULT_LOCALE)
 	@Mapping(target = "internationalizationEnabled", constant = INTERNATIONALIZATION_ENABLED)
 	@Mapping(target = "passwordPolicy", constant = PASSWORD_POLICY)
 	@Mapping(target = "actionTokenGeneratedByUserLifespan", constant = ACTION_TOKEN_GENERATED_BY_USER_LIFE_SPAN)
@@ -57,11 +59,11 @@ interface KeycloakRealmMapper {
 	@Mapping(target = "roles.realm", source = "realmRoles")
 	public RealmRepresentation map(OzgCloudKeycloakRealmSpec realm);
 
-	@Mapping(target = "displayName", source = "displayName")
+
 	@Mapping(target = "enabled", constant = ENABLED)
 	@Mapping(target = "resetPasswordAllowed", constant = RESET_PASSWORD_ALLOWED)
 	@Mapping(target = "supportedLocales", source = ".", qualifiedByName = "supportedLocales")
-	@Mapping(target = "defaultLocale", constant = DEFAULT_LOCAL)
+	@Mapping(target = "defaultLocale", constant = DEFAULT_LOCALE)
 	@Mapping(target = "internationalizationEnabled", constant = INTERNATIONALIZATION_ENABLED)
 	@Mapping(target = "passwordPolicy", constant = PASSWORD_POLICY)
 	@Mapping(target = "actionTokenGeneratedByUserLifespan", constant = ACTION_TOKEN_GENERATED_BY_USER_LIFE_SPAN)
@@ -82,14 +84,14 @@ interface KeycloakRealmMapper {
 
 		Map<String, String> smtpServer = new HashMap<>();
 		if (server != null) {
-			smtpServer.put("host", server.getHost());
-			smtpServer.put("port", server.getPort());
-			smtpServer.put("user", server.getUser());
-			smtpServer.put("password", server.getPassword());
-			smtpServer.put("starttls", server.getStarttls());
-			smtpServer.put("auth", server.getAuth());
-			smtpServer.put("from", server.getFrom());
-			smtpServer.put("fromDisplayName", server.getFromDisplayName());
+			smtpServer.put(KeycloakRealmSMTPServer.HOST_FIELD, server.getHost());
+			smtpServer.put(KeycloakRealmSMTPServer.PORT_FIELD, server.getPort());
+			smtpServer.put(KeycloakRealmSMTPServer.USER_FIELD, server.getUser());
+			smtpServer.put(KeycloakRealmSMTPServer.PASSWORD_FIELD, server.getPassword());
+			smtpServer.put(KeycloakRealmSMTPServer.STARTTLS_FIELD, server.getStarttls());
+			smtpServer.put(KeycloakRealmSMTPServer.AUTH_FIELD, server.getAuth());
+			smtpServer.put(KeycloakRealmSMTPServer.FROM_FIELD, server.getFrom());
+			smtpServer.put(KeycloakRealmSMTPServer.FROM_DISPLAY_NAME_FIELD, server.getFromDisplayName());
 		}
 		return smtpServer;
 

ozgcloud-keycloak-operator/src/main/java/de/ozgcloud/operator/keycloak/realm/KeycloakRealmService.java

@@ -51,7 +51,7 @@ class KeycloakRealmService {
 				.ifPresent(remoteService::createRealm);
 	}
 
-	void createOrUpdateRealm(OzgCloudKeycloakRealmSpec realm, String realmName) {
+	public void createOrUpdateRealm(OzgCloudKeycloakRealmSpec realm, String realmName) {
 		keycloakGenericRemoteService.getRealmRepresentation(realmName)
 				.ifPresentOrElse(existingRealm -> updateRealm(existingRealm, realm),
 						() -> createRealm(realm, realmName));

ozgcloud-keycloak-operator/src/main/java/de/ozgcloud/operator/keycloak/realm/OzgCloudKeycloakRealmSpec.java

@@ -57,6 +57,22 @@ class OzgCloudKeycloakRealmSpec {
 	@AllArgsConstructor
 	static class KeycloakRealmSMTPServer {
 
+		public static final String USER_FIELD = "user";
+
+		public static final String PASSWORD_FIELD = "password";
+
+		public static final String HOST_FIELD = "host";
+
+		public static final String PORT_FIELD= "port";
+
+		public static final String STARTTLS_FIELD = "starttls"; 
+
+		public static final String AUTH_FIELD = "auth";
+
+		public static final String FROM_FIELD = "from";
+
+		public static final String FROM_DISPLAY_NAME_FIELD = "fromDisplayName";
+
 		private String user;
 		private String password;
 

ozgcloud-keycloak-operator/src/test/java/de/ozgcloud/operator/keycloak/realm/KeycloakRealmMapperTest.java

@@ -31,87 +31,95 @@ import org.keycloak.representations.idm.RealmRepresentation;
 import org.mapstruct.factory.Mappers;
 import org.mockito.Spy;
 
+import de.ozgcloud.operator.keycloak.realm.OzgCloudKeycloakRealmSpec.KeycloakRealmSMTPServer;
+
 class KeycloakRealmMapperTest {
 
 	@Spy
 	private final KeycloakRealmMapper mapper = Mappers.getMapper(KeycloakRealmMapper.class);
 
+
+	private RealmRepresentation mapRealm() {
+        return mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+
+	}
+
 	@Test
 	void shouldMapDisplayName() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getDisplayName()).isEqualTo(OzgCloudKeycloakRealmSpecTestFactory.DISPLAY_NAME);
 	}
 
 	@Test
 	void shouldBeEnabled() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.isEnabled()).isTrue();
 	}
 
 	@Test
 	void shouldBeResetPasswordAllowed() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.isResetPasswordAllowed()).isTrue();
 	}
 
 	@Test
 	void shouldBeSupportedLocaleDe() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getSupportedLocales()).containsExactly("de");
 	}
 
 	@Test
 	void shouldBeDefaultLocaleDe() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getDefaultLocale()).isEqualTo("de");
 	}
 
 	@Test
 	void shouldBeInternationalizationEnabled() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.isInternationalizationEnabled()).isTrue();
 	}
 
 	@Test
 	void checkPasswordPolicy() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getPasswordPolicy()).isEqualTo("upperCase(1) and lowerCase(1) and length(8) and notUsername");
 	}
 
 	@Test
 	void shouldSetActionTokenGeneratedByUserLifespan() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getActionTokenGeneratedByUserLifespan()).isEqualTo(900);
 	}
 
 	@Test
 	void shouldMapSmtpServer() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getSmtpServer()).hasSize(8);
 	}
 
 	@Test
 	void shouldContainSmtpServerKeysValues() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getSmtpServer())
-				.containsEntry("user", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_USER)
-				.containsEntry("password", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PASSWORD)
-				.containsEntry("host", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_HOST)
-				.containsEntry("port", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PORT)
-				.containsEntry("starttls", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_STARTTLS)
-				.containsEntry("auth", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_AUTH)
-				.containsEntry("from", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM)
-				.containsEntry("fromDisplayName", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM_DISPLAY_NAME);
+				.containsEntry(KeycloakRealmSMTPServer.USER_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_USER)
+				.containsEntry(KeycloakRealmSMTPServer.PASSWORD_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PASSWORD)
+				.containsEntry(KeycloakRealmSMTPServer.HOST_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_HOST)
+				.containsEntry(KeycloakRealmSMTPServer.PORT_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PORT)
+				.containsEntry(KeycloakRealmSMTPServer.STARTTLS_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_STARTTLS)
+				.containsEntry(KeycloakRealmSMTPServer.AUTH_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_AUTH)
+				.containsEntry(KeycloakRealmSMTPServer.FROM_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM)
+				.containsEntry(KeycloakRealmSMTPServer.FROM_DISPLAY_NAME_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM_DISPLAY_NAME);
 	}
 
 	@Test
@@ -123,14 +131,14 @@ class KeycloakRealmMapperTest {
 
 	@Test
 	void shouldMapRealmRoles() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 
 		assertThat(mapped.getRoles().getRealm()).hasSize(2);
 	}
 
 	@Test
 	void shouldContainRealmRolesValues() {
-		var mapped = mapper.map(OzgCloudKeycloakRealmSpecTestFactory.create());
+		var mapped = mapRealm();
 		var mappedRealmRoles = mapped.getRoles();
 
 		assertThat(mappedRealmRoles.getRealm().get(0).getName()).isEqualTo(OzgCloudKeycloakRealmSpecTestFactory.ROLE_NAME_1);
@@ -142,99 +150,99 @@ class KeycloakRealmMapperTest {
 
 		@Test
 		void shouldMapDisplayName() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getDisplayName()).isEqualTo(OzgCloudKeycloakRealmSpecTestFactory.DISPLAY_NAME);
 		}
 
 		@Test
 		void shouldBeEnabled() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.isEnabled()).isTrue();
 		}
 
 		@Test
 		void shouldBeResetPasswordAllowed() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.isResetPasswordAllowed()).isTrue();
 		}
 
 		@Test
 		void shouldBeSupportedLocaleDe() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getSupportedLocales()).containsExactly("de");
 		}
 
 		@Test
 		void shouldBeDefaultLocaleDe() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getDefaultLocale()).isEqualTo("de");
 		}
 
 		@Test
 		void shouldBeInternationalizationEnabled() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.isInternationalizationEnabled()).isTrue();
 		}
 
 		@Test
 		void checkPasswordPolicy() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getPasswordPolicy()).isEqualTo("upperCase(1) and lowerCase(1) and length(8) and notUsername");
 		}
 
 		@Test
 		void shouldSetActionTokenGeneratedByUserLifespan() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getActionTokenGeneratedByUserLifespan()).isEqualTo(900);
 		}
 
 		@Test
 		void shouldMapSmtpServer() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getSmtpServer()).hasSize(8);
 		}
 
 		@Test
 		void shouldContainSmtpServerKeysValues() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getSmtpServer())
-					.containsEntry("user", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_USER)
-					.containsEntry("password", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PASSWORD)
-					.containsEntry("host", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_HOST)
-					.containsEntry("port", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PORT)
-					.containsEntry("starttls", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_STARTTLS)
-					.containsEntry("auth", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_AUTH)
-					.containsEntry("from", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM)
-					.containsEntry("fromDisplayName", KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM_DISPLAY_NAME);
+					.containsEntry(KeycloakRealmSMTPServer.USER_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_USER)
+					.containsEntry(KeycloakRealmSMTPServer.PASSWORD_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PASSWORD)
+					.containsEntry(KeycloakRealmSMTPServer.HOST_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_HOST)
+					.containsEntry(KeycloakRealmSMTPServer.PORT_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_PORT)
+					.containsEntry(KeycloakRealmSMTPServer.STARTTLS_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_STARTTLS)
+					.containsEntry(KeycloakRealmSMTPServer.AUTH_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_AUTH)
+					.containsEntry(KeycloakRealmSMTPServer.FROM_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM)
+					.containsEntry(KeycloakRealmSMTPServer.FROM_DISPLAY_NAME_FIELD, KeycloakRealmSmtpServerTestFactory.SMTP_SERVER_FROM_DISPLAY_NAME);
 		}
 
 		@Test
 		void shouldMapWhenSmtpServerIsNull() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.createBuilder().smtpServer(null).build());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.createBuilder().smtpServer(null).build());
 
 			assertThat(mapped.getSmtpServer()).isEmpty();
 		}
 
 		@Test
 		void shouldMapRealmRoles() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 
 			assertThat(mapped.getRoles().getRealm()).hasSize(2);
 		}
 
 		@Test
 		void shouldContainRealmRolesValues() {
-			var mapped = mapper.update(new RealmRepresentation(), OzgCloudKeycloakRealmSpecTestFactory.create());
+			var mapped = mapper.update(RealmRepresentationTestFactory.create(), OzgCloudKeycloakRealmSpecTestFactory.create());
 			var mappedRealmRoles = mapped.getRoles();
 
 			assertThat(mappedRealmRoles.getRealm().get(0).getName()).isEqualTo(OzgCloudKeycloakRealmSpecTestFactory.ROLE_NAME_1);

ozgcloud-keycloak-operator/src/test/java/de/ozgcloud/operator/keycloak/realm/KeycloakRealmRemoteServiceTest.java

@@ -23,10 +23,10 @@
  */
 package de.ozgcloud.operator.keycloak.realm;
 
+import static org.mockito.Mockito.*;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.mockito.ArgumentMatchers.any;
 
 import java.util.List;
 import java.util.Optional;
@@ -70,8 +70,8 @@ class KeycloakRealmRemoteServiceTest {
 	@Mock
 	private RoleRepresentation roleRepresentation;
 
-	private static final String REALM_NAME = "TestRealmName";
-	private static final String ROLE_NAME = "RoleName";
+	private static final String REALM_NAME = RealmRepresentationTestFactory.NAME;
+	private static final String ROLE_NAME = OzgCloudKeycloakRealmSpecTestFactory.ROLE_NAME_1;
 
 	@Nested
 	class TestCreateRealm {
@@ -91,6 +91,24 @@ class KeycloakRealmRemoteServiceTest {
 		}
 	}
 
+	@Nested
+	class TestUpdateRealm {
+
+		@BeforeEach
+		void init() {
+			when(keycloak.realm(REALM_NAME)).thenReturn(realmResource);
+		}
+
+		@Test
+		void shouldCallUpdateRealm() {
+			var realm = RealmRepresentationTestFactory.create();
+
+			remoteService.updateRealm(realm);
+
+			verify(realmResource).update(realm);
+		}
+	}
+	
 	@Nested
 	class TestDeleteRealm {
 
@@ -108,16 +126,16 @@ class KeycloakRealmRemoteServiceTest {
 	class TestRealmRoles {
 
 		@Nested
-		class TestAddClientRole {
+		class TestAddRealmRole {
 
 			@BeforeEach
 			void init() {
-				when(keycloak.realm(REALM_NAME)).thenReturn(realmResource);
+				when(keycloak.realm(any())).thenReturn(realmResource);
 				when(realmResource.roles()).thenReturn(rolesResource);
 			}
 
 			@Test
-			void shouldAddClientRole() {
+			void shouldAddRealmRole() {
 				remoteService.addRealmRole(roleRepresentation, REALM_NAME);
 
 				verify(rolesResource).create(roleRepresentation);
@@ -132,7 +150,6 @@ class KeycloakRealmRemoteServiceTest {
 				when(keycloak.realm(REALM_NAME)).thenReturn(realmResource);
 				when(realmResource.roles()).thenReturn(rolesResource);
 				when(rolesResource.get(ROLE_NAME)).thenReturn(roleResource);
-
 				when(roleRepresentation.getName()).thenReturn(ROLE_NAME);
 
 			}

ozgcloud-keycloak-operator/src/test/java/de/ozgcloud/operator/keycloak/realm/KeycloakRealmServiceTest.java

@@ -38,11 +38,15 @@ import org.mockito.Mock;
 import org.mockito.Spy;
 
 import de.ozgcloud.operator.keycloak.KeycloakGenericRemoteService;
+import de.ozgcloud.operator.keycloak.realm.OzgCloudKeycloakRealmSpec.RealmRole;
 
 class KeycloakRealmServiceTest {
 
 	private static final OzgCloudKeycloakRealmSpec REALM = OzgCloudKeycloakRealmSpecTestFactory.create();
 	private static final String REALM_NAME = "TestRealmName";
+	private static final String ROLE_NAME = OzgCloudKeycloakRealmSpecTestFactory.ROLE_NAME_1;
+	private static final RealmRole ROLE = OzgCloudKeycloakRealmSpecTestFactory.ROLE1;
+
 
 	@Spy
 	@InjectMocks
@@ -115,6 +119,53 @@ class KeycloakRealmServiceTest {
 			verify(mapper).update(realmRepresentation, REALM);
 		}
 
+		@Test
+		void shouldCallAddOrUpdateRealmRoles() {
+
+			service.updateRealm(realmRepresentation, REALM);
+
+			verify(service).addOrUpdateRealmRoles(REALM, realmRepresentation.getRealm());
+		}
+
+	}
+
+	
+
+	@DisplayName("Add or Update Realm Roles")
+	@Nested
+	class TestAddOrUpdateRealmRoles {
+
+		@Test
+		void shouldCallRemoteServiceGetRole() {
+
+			service.addOrUpdateRealmRoles(REALM, REALM_NAME);
+
+			verify(remoteService).getRealmRole(ROLE_NAME, REALM_NAME);
+		}
+
+		@Test
+		void shouldCreateRole() {
+			when(remoteService.getRealmRole(ROLE_NAME, REALM_NAME)).thenReturn(Optional.empty());
+			var roleRepresentation = RealmRoleRepresentationTestFactory.create();
+			when(mapper.map(ROLE)).thenReturn(roleRepresentation);
+
+			service.addOrUpdateRealmRoles(REALM, REALM_NAME);
+
+			verify(remoteService).addRealmRole(roleRepresentation, REALM_NAME);
+		}
+
+		@Test
+		void shouldUpdateRole() {
+			var roleRepresentation = RealmRoleRepresentationTestFactory.create();
+			when(mapper.map(ROLE)).thenReturn(roleRepresentation);
+			when(remoteService.getRealmRole(ROLE_NAME, REALM_NAME)).thenReturn(Optional.of(roleRepresentation));
+			
+
+			service.addOrUpdateRealmRoles(REALM, REALM_NAME);
+
+			verify(remoteService).updateRealmRole(roleRepresentation, REALM_NAME);
+		}
+
 	}
 
 	@Nested

ozgcloud-keycloak-operator/src/test/java/de/ozgcloud/operator/keycloak/realm/RealmRoleRepresentationTestFactory.java

+/*
+ * Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
+ * Ministerpräsidenten des Landes Schleswig-Holstein
+ * Staatskanzlei
+ * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+ *
+ * Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ * diese von der Europäischen Kommission genehmigt wurden -
+ * Folgeversionen der EUPL ("Lizenz");
+ * Sie dürfen dieses Werk ausschließlich gemäß
+ * dieser Lizenz nutzen.
+ * Eine Kopie der Lizenz finden Sie hier:
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Sofern nicht durch anwendbare Rechtsvorschriften
+ * gefordert oder in schriftlicher Form vereinbart, wird
+ * die unter der Lizenz verbreitete Software "so wie sie
+ * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ * ausdrücklich oder stillschweigend - verbreitet.
+ * Die sprachspezifischen Genehmigungen und Beschränkungen
+ * unter der Lizenz sind dem Lizenztext zu entnehmen.
+ */
+package de.ozgcloud.operator.keycloak.realm;
+
+import org.keycloak.representations.idm.RoleRepresentation;
+
+public class RealmRoleRepresentationTestFactory {
+
+	public static RoleRepresentation create() {
+		var role = new RoleRepresentation();
+		role.setName(OzgCloudKeycloakRealmSpecTestFactory.ROLE_NAME_1);
+
+		return role;
+	}
+}