OZG-4453 impl reconciler#cleanup

ozgcloud-elasticsearch-operator/src/main/java/de/ozgcloud/operator/ElasticsearchReconciler.java

 package de.ozgcloud.operator;
 
+import java.util.logging.Level;
+
 import org.apache.commons.collections.MapUtils;
 import org.springframework.stereotype.Component;
 
@@ -19,17 +21,17 @@ import lombok.extern.java.Log;
 @Component
 public class ElasticsearchReconciler implements Reconciler<OzgCloudElasticsearchCustomResource>, Cleaner<OzgCloudElasticsearchCustomResource>  {
 
-	private final OzgCloudElasticsearchService searchService;
+	private final OzgCloudElasticsearchService service;
 
 	@Override
 	public UpdateControl<OzgCloudElasticsearchCustomResource> reconcile(OzgCloudElasticsearchCustomResource resource, Context<OzgCloudElasticsearchCustomResource> context) {
 		try {
 			log.info("Reconcile user " + resource.getCRDName() + "...");
 			var namespace = resource.getMetadata().getNamespace();
-			var secret = searchService.getOrCreateCredentialSecret(resource, context);
-			searchService.createIndexIfMissing(namespace);
-			searchService.createSecurityRoleIfMissing(namespace);
-			searchService.checkSecurityUser(namespace, getPassword(secret));
+			var secret = service.getOrCreateCredentialSecret(resource, context);
+			service.createIndexIfMissing(namespace);
+			service.createSecurityRoleIfMissing(namespace);
+			service.createSecurityUserIfMissing(namespace, getPassword(secret));
 			log.info("Reconcile user successful.");
 			return OzgCloudElasticsearchUpdateControlBuilder.fromResource(resource).withStatus(CustomResourceStatus.OK).build();
 		} catch (Exception e) {
@@ -53,6 +55,15 @@ public class ElasticsearchReconciler implements Reconciler<OzgCloudElasticsearch
 	
 	@Override
 	public DeleteControl cleanup(OzgCloudElasticsearchCustomResource resource, Context<OzgCloudElasticsearchCustomResource> context) {
+		var namespace = resource.getMetadata().getNamespace();
+		try {
+			service.deleteSecurityUserIfExists(namespace);
+			service.deleteSecurityRoleIfExists(namespace);
+			service.deleteIndexIfExists(namespace);
 			return DeleteControl.defaultDelete();
+		} catch(Exception e) {
+			log.log(Level.INFO, String.format("Could not cleanup elasticsearch resource in namespace %s. \n %s", namespace, e));
+			return DeleteControl.defaultDelete();
+		}
 	}
 }
\ No newline at end of file

ozgcloud-elasticsearch-operator/src/main/java/de/ozgcloud/operator/OzgCloudElasticsearchService.java

@@ -86,7 +86,7 @@ public class OzgCloudElasticsearchService {
 	
 //	 curl -k -X POST -u elastic:$ELASTICSEARCH_PASSWORD -H 'Content-Type: application/json' 
 //	'https://ozg-search-cluster-es-http:9200/_security/user/'$ES_NS_USER -d '{"password" : "'$ES_NS_PASSWORD'" ,"roles" : [ "'$ES_NS_USER'" ]}'
-	public void checkSecurityUser(String namespace, String password) throws Exception {
+	public void createSecurityUserIfMissing(String namespace, String password) throws Exception {
 		log.info("Check security user...");
 		if(!remoteService.existsSecurityUser(namespace)) {
 			remoteService.createSecurityUser(buildPutUserRequestData(namespace, password));
@@ -98,7 +98,27 @@ public class OzgCloudElasticsearchService {
 		return PutUserRequestData.builder().username(namespace).roles(namespace).password(password).build();
 	}
 	
-	public void deleteIndexIfExists(String name) {
+	public void deleteSecurityUserIfExists(String userName) throws Exception {
+		log.info("Delete security user...");
+		if(remoteService.existsSecurityUser(userName)) {
+			remoteService.deleteSecurityUser(userName);
+		}
+		log.info("Delete security user successful.");
+	}
+	
+	public void deleteSecurityRoleIfExists(String roleName) throws Exception  {
+		log.info("Delete security role...");
+		if(remoteService.existsSecurityRole(roleName)) {
+			remoteService.deleteSecurityRole(roleName);
+		}
+		log.info("Delete security role successful.");
+	}
 
+	public void deleteIndexIfExists(String indexName) throws Exception  {
+		log.info("Delete index role...");
+		if(remoteService.existsIndex(indexName)) {
+			remoteService.deleteIndex(indexName);
+		}
+		log.info("Delete index role successful.");
 	}
 }
\ No newline at end of file

ozgcloud-elasticsearch-operator/src/main/java/de/ozgcloud/operator/common/elasticsearch/ElasticsearchRemoteService.java

@@ -7,9 +7,6 @@ import org.springframework.stereotype.Component;
 
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
 import co.elastic.clients.elasticsearch._types.ElasticsearchException;
-import co.elastic.clients.elasticsearch.indices.ExistsRequest;
-import co.elastic.clients.elasticsearch.security.GetRoleRequest;
-import co.elastic.clients.elasticsearch.security.GetUserRequest;
 import co.elastic.clients.elasticsearch.security.IndicesPrivileges;
 import co.elastic.clients.elasticsearch.security.PutRoleRequest;
 import co.elastic.clients.elasticsearch.security.PutUserRequest;
@@ -28,7 +25,7 @@ public class ElasticsearchRemoteService {
 	public boolean existsIndex(String index) throws Exception {
 		try {
 			log.info("Exists index " + index + "...");
-			var exists = client.indices().exists(createExistsRequest(index)).value();
+			var exists = client.indices().exists(builder -> builder.index(index)).value();
 			log.info("Exists index: " + exists);
 			return exists;
 		} catch (ElasticsearchException | IOException e) {
@@ -37,10 +34,6 @@ public class ElasticsearchRemoteService {
 		}
 	}
 	
-	ExistsRequest createExistsRequest(String index) {
-		return ExistsRequest.of(builder -> builder.index(index));
-	}
-	
 	public void createIndex(String indexName) throws Exception {
 		try {
 			log.info("Create index " + indexName + "...");
@@ -53,12 +46,7 @@ public class ElasticsearchRemoteService {
 	}
 	
 	public boolean existsSecurityRole(String roleName) throws Exception {
-		var role = client.security().getRole(createGetRoleRequest(roleName));
-		return !role.result().isEmpty();                  
-	}
-	
-	GetRoleRequest createGetRoleRequest(String name) {
-		return GetRoleRequest.of(builder -> builder.name(name));
+		return !client.security().getRole(builder -> builder.name(roleName)).result().isEmpty();
 	}
 	
 	public void createSecurityRole(PutRoleRequestData requestData) throws Exception {
@@ -91,12 +79,7 @@ public class ElasticsearchRemoteService {
 	}
 		
 	public boolean existsSecurityUser(String userName) throws Exception {
-		var user = client.security().getUser(createGetUserRequest(userName));
-		return !user.result().isEmpty();       
-	}
-	
-	private GetUserRequest createGetUserRequest(String userName) {
-		return GetUserRequest.of(builder -> builder.username(userName));
+		return !client.security().getUser(builder -> builder.username(userName)).result().isEmpty();
 	}
 	
 	public void createSecurityUser(PutUserRequestData requestData) throws Exception {
@@ -121,4 +104,37 @@ public class ElasticsearchRemoteService {
 		
 		return builder;
 	}
+	
+	public void deleteIndex(String indexName) throws Exception {
+		try {
+			log.info("Delete index " + indexName + "...");
+			client.indices().delete(builder -> builder.index(indexName));
+			log.info("Delete index successful.");
+		} catch(Exception e) {
+			log.log(Level.SEVERE, "Delete index failed." + e);
+			throw e;
+		}
+	}
+	
+	public void deleteSecurityRole(String roleName) throws Exception {
+		try {
+			log.info("Delete security role " + roleName + "...");
+			client.security().deleteRole(builder -> builder.name(roleName));
+			log.info("Delete security role successful.");
+		} catch(Exception e) {
+			log.log(Level.SEVERE, "Delete security role failed." + e);
+			throw e;
+		}
+	}
+	
+	public void deleteSecurityUser(String userName) throws Exception {
+		try {
+			log.info("Delete security user " + userName + "...");
+			client.security().deleteUser(builder -> builder.username(userName));
+			log.info("Delete security user successful.");
+		} catch(Exception e) {
+			log.log(Level.SEVERE, "Delete security user failed." + e);
+			throw e;
+		}
+	}
 }
\ No newline at end of file

ozgcloud-elasticsearch-operator/src/test/java/de/ozgcloud/operator/ElasticsearchReconcilerTest.java

@@ -25,7 +25,7 @@ class ElasticsearchReconcilerTest {
 	@InjectMocks
 	private ElasticsearchReconciler reconciler;
 	@Mock
-	private OzgCloudElasticsearchService searchService;
+	private OzgCloudElasticsearchService service;
 
 	@DisplayName("Reconcile")
 	@Nested
@@ -45,14 +45,14 @@ class ElasticsearchReconcilerTest {
 			
 			@BeforeEach
 			void mockCredentialSecret() {
-				when(searchService.getOrCreateCredentialSecret(any(), any())).thenReturn(secret);
+				when(service.getOrCreateCredentialSecret(any(), any())).thenReturn(secret);
 			}
 			
 			@Test
 			void shouldGetCredentialSecret() {
 				reconcile();
 				
-				verify(searchService).getOrCreateCredentialSecret(resource, context);
+				verify(service).getOrCreateCredentialSecret(resource, context);
 			}
 			
 			@SneakyThrows
@@ -60,7 +60,7 @@ class ElasticsearchReconcilerTest {
 			void shouldCheckIndex() {
 				reconcile();
 				
-				verify(searchService).createIndexIfMissing(NamespaceTestFactory.NAMESPACE);
+				verify(service).createIndexIfMissing(NamespaceTestFactory.NAMESPACE);
 			}
 			
 			@SneakyThrows
@@ -68,7 +68,7 @@ class ElasticsearchReconcilerTest {
 			void shouldCheckSecurityRole() {
 				reconcile();
 				
-				verify(searchService).createSecurityRoleIfMissing(NamespaceTestFactory.NAMESPACE);
+				verify(service).createSecurityRoleIfMissing(NamespaceTestFactory.NAMESPACE);
 			}
 			
 			@SneakyThrows
@@ -76,7 +76,7 @@ class ElasticsearchReconcilerTest {
 			void shouldCheckSecurityUser() {
 				reconcile();
 				
-				verify(searchService).checkSecurityUser(NamespaceTestFactory.NAMESPACE, PASSWORD);
+				verify(service).createSecurityUserIfMissing(NamespaceTestFactory.NAMESPACE, PASSWORD);
 			}
 		}
 		
@@ -88,7 +88,7 @@ class ElasticsearchReconcilerTest {
 			
 			@BeforeEach
 			void mock() {
-				when(searchService.getOrCreateCredentialSecret(any(), any())).thenThrow(exception);
+				when(service.getOrCreateCredentialSecret(any(), any())).thenThrow(exception);
 			}
 			
 			@Test
@@ -155,6 +155,30 @@ class ElasticsearchReconcilerTest {
 		
 		private final OzgCloudElasticsearchCustomResource resource = ElasticsearchCustomResourceTestFactory.create();
 		
+		@SneakyThrows
+		@Test
+		void shouldDeleteSecurityUser() {
+			reconciler.cleanup(resource, context);
+			
+			verify(service).deleteSecurityUserIfExists(NamespaceTestFactory.NAMESPACE);
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteSecurityRole() {
+			reconciler.cleanup(resource, context);
+			
+			verify(service).deleteSecurityRoleIfExists(NamespaceTestFactory.NAMESPACE);
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteIndex() {
+			reconciler.cleanup(resource, context);
+			
+			verify(service).deleteIndexIfExists(NamespaceTestFactory.NAMESPACE);
+		}
+		
 		@Test
 		void shouldReturnDeleteControl(){
 			var deleteControl = reconciler.cleanup(resource, context);

ozgcloud-elasticsearch-operator/src/test/java/de/ozgcloud/operator/OzgCloudElasticsearchServiceTest.java

@@ -200,7 +200,7 @@ class OzgCloudElasticsearchServiceTest {
 		@SneakyThrows
 		@Test
 		void shouldCheckIfSecurityUserExists() {
-			service.checkSecurityUser(NAMESPACE, PutUserRequestDataTestFactory.PASSWORD);
+			service.createSecurityUserIfMissing(NAMESPACE, PutUserRequestDataTestFactory.PASSWORD);
 			
 			verify(remoteService).existsSecurityUser(NAMESPACE);
 		}
@@ -211,7 +211,7 @@ class OzgCloudElasticsearchServiceTest {
 			when(remoteService.existsSecurityUser(any())).thenReturn(false);
 			doReturn(putUserRequestData).when(service).buildPutUserRequestData(any(), any());
 			
-			service.checkSecurityUser(NAMESPACE, PutUserRequestDataTestFactory.PASSWORD);
+			service.createSecurityUserIfMissing(NAMESPACE, PutUserRequestDataTestFactory.PASSWORD);
 			
 			verify(remoteService).createSecurityUser(putUserRequestData);
 		}
@@ -246,4 +246,75 @@ class OzgCloudElasticsearchServiceTest {
 			}
 		}
 	}
+	
+	@DisplayName("Delete security user if exists")
+	@Nested
+	class TestDeleteSecurityUserIfExists {
+		
+		@SneakyThrows
+		@Test
+		void shouldCheckIfSecurityUserExists() {
+			service.deleteSecurityUserIfExists(PutUserRequestDataTestFactory.USERNAME);
+			
+			verify(remoteService).existsSecurityUser(PutUserRequestDataTestFactory.USERNAME);
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteSecurityUserIfExists() {
+			when(remoteService.existsSecurityUser(any())).thenReturn(true);
+			
+			service.deleteSecurityUserIfExists(PutUserRequestDataTestFactory.USERNAME);
+			
+			verify(remoteService).deleteSecurityUser(PutUserRequestDataTestFactory.USERNAME);
+		}
+	}
+	
+	@DisplayName("Delete security role if exists")
+	@Nested
+	class TestDeleteSecurityRoleIfExists {
+		
+		@SneakyThrows
+		@Test
+		void shouldCheckIfSecurityRoleExists() {
+			service.deleteSecurityRoleIfExists(PutRoleRequestDataTestFactory.NAME);
+			
+			verify(remoteService).existsSecurityRole(PutRoleRequestDataTestFactory.NAME);
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteSecurityRoleIfExists() {
+			when(remoteService.existsSecurityRole(any())).thenReturn(true);
+			
+			service.deleteSecurityRoleIfExists(PutRoleRequestDataTestFactory.NAME);
+			
+			verify(remoteService).deleteSecurityRole(PutRoleRequestDataTestFactory.NAME);
+		}
+	}
+	
+	@DisplayName("Delete index if exists")
+	@Nested
+	class TestDeleteIndexIfExists {
+		
+		private static final String INDEX_NAME = NamespaceTestFactory.NAMESPACE;
+		
+		@SneakyThrows
+		@Test
+		void shouldCheckIfIndexExists() {
+			service.deleteIndexIfExists(INDEX_NAME);
+			
+			verify(remoteService).existsIndex(INDEX_NAME);
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteSecurityRoleIfExists() {
+			when(remoteService.existsIndex(any())).thenReturn(true);
+			
+			service.deleteIndexIfExists(INDEX_NAME);
+			
+			verify(remoteService).deleteIndex(INDEX_NAME);
+		}
+	}
 }
\ No newline at end of file

ozgcloud-elasticsearch-operator/src/test/java/de/ozgcloud/operator/common/elasticsearch/ElasticsearchRemoteServiceITCase.java

@@ -11,12 +11,11 @@ import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
-import co.elastic.clients.elasticsearch.indices.DeleteIndexRequest;
 import co.elastic.clients.elasticsearch.indices.ExistsRequest;
-import co.elastic.clients.elasticsearch.security.DeleteRoleRequest;
-import co.elastic.clients.elasticsearch.security.DeleteUserRequest;
-import co.elastic.clients.elasticsearch.security.GetRoleRequest;
-import co.elastic.clients.elasticsearch.security.GetUserRequest;
+import co.elastic.clients.elasticsearch.security.IndicesPrivileges;
+import co.elastic.clients.elasticsearch.security.PutRoleRequest;
+import co.elastic.clients.elasticsearch.security.PutUserRequest;
+import de.ozgcloud.operator.IndicesPrivilegesDataTestFactory;
 import de.ozgcloud.operator.PutRoleRequestDataTestFactory;
 import de.ozgcloud.operator.PutUserRequestDataTestFactory;
 import lombok.SneakyThrows;
@@ -91,16 +90,6 @@ class ElasticsearchRemoteServiceITCase {
 			
 			assertThat(existsIndex()).isTrue();
 		}
-		
-		@SneakyThrows
-		private boolean existsIndex() {
-			return client.indices().exists(ExistsRequest.of(builder -> builder.index(INDEX_NAME))).value();
-		}
-	}
-	
-	@SneakyThrows
-	private void deleteIndex() {
-		client.indices().delete(DeleteIndexRequest.of(builder -> builder.index(INDEX_NAME)));
 	}
 	
 	@DisplayName("Exists security role")
@@ -158,15 +147,9 @@ class ElasticsearchRemoteServiceITCase {
 			assertThat(existsSecurityRole()).isTrue();
 		}
 		
-		@SneakyThrows
-		private boolean existsSecurityRole() {
-			var role = client.security().getRole(GetRoleRequest.of(builder -> builder.name(PutRoleRequestDataTestFactory.NAME)));
-			return !role.result().isEmpty();
-		}
-		
 		@SneakyThrows
 		private void deleteSecurityRole() {
-			client.security().deleteRole(DeleteRoleRequest.of(builder -> builder.name(PutRoleRequestDataTestFactory.NAME)));
+			client.security().deleteRole(builder -> builder.name(PutRoleRequestDataTestFactory.NAME));
 		}
 	}
 	
@@ -188,6 +171,7 @@ class ElasticsearchRemoteServiceITCase {
 			@AfterEach
 			void cleanup() {
 				deleteIndex();
+				deleteSecurityRole();
 			}
 			
 			@SneakyThrows
@@ -209,8 +193,12 @@ class ElasticsearchRemoteServiceITCase {
 	}
 	
 	@SneakyThrows
-	private void createIndex() {
-		client.indices().create(builder -> builder.index(INDEX_NAME));
+	private void deleteSecurityRole() {
+		client.security().deleteUser(builder -> builder.username(PutUserRequestDataTestFactory.USERNAME));
+	}
+	@SneakyThrows
+	private void deleteIndex() {
+		client.indices().delete(builder -> builder.index(INDEX_NAME));
 	}
 	
 	@DisplayName("Create security user")
@@ -232,13 +220,133 @@ class ElasticsearchRemoteServiceITCase {
 		
 		@SneakyThrows
 		private boolean existsSecurityUser() {
-			var user = client.security().getUser(GetUserRequest.of(builder -> builder.username(PutUserRequestDataTestFactory.USERNAME)));
-			return !user.result().isEmpty();     
+			return !client.security().getUser(builder -> builder.username(PutUserRequestDataTestFactory.USERNAME)).result().isEmpty();
 		}
 		
 		@SneakyThrows
 		private void deleteSecurityUser() {
-			client.security().deleteUser(DeleteUserRequest.of(builder -> builder.username(PutUserRequestDataTestFactory.USERNAME)));
+			client.security().deleteUser(builder -> builder.username(PutUserRequestDataTestFactory.USERNAME));
+		}
+	}
+	
+	@DisplayName("Delete index")
+	@Nested
+	class TestDeleteIndex {
+		
+		@BeforeEach
+		void init() {
+			createIndex();
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteIfExists() {			
+			service.deleteIndex(INDEX_NAME);
+			
+			assertThat(existsIndex()).isFalse();
+		}
+	}
+	
+	@DisplayName("Delete security role")
+	@Nested
+	class TestDeleteSecurityRole {
+		
+		@BeforeEach
+		void init() {
+			createIndex();
+			createSecurityRole();
+		}
+		
+		@AfterEach
+		void cleanup() {
+			deleteIndex();
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteIfExists() {
+			assertThat(existsSecurityRole()).isTrue();
+			
+			service.deleteSecurityRole(PutRoleRequestDataTestFactory.NAME);
+			
+			assertThat(existsSecurityRole()).isFalse();
 		}
 	}
+	
+	@DisplayName("Delete security user")
+	@Nested
+	class TestDeleteSecurityUser {
+		
+		@BeforeEach
+		void init() {
+			createIndex();
+			createSecurityUser();
+		}
+		
+		@AfterEach
+		void cleanup() {
+			deleteIndex();
+		}
+		
+		@SneakyThrows
+		@Test
+		void shouldDeleteIfExists() {
+			assertThat(existsSecurityUser()).isTrue();
+			
+			service.deleteSecurityUser(PutUserRequestDataTestFactory.USERNAME);
+			
+			assertThat(existsSecurityUser()).isFalse();
+		}
+	}
+	
+	@SneakyThrows
+	private boolean existsIndex() {
+		return client.indices().exists(ExistsRequest.of(builder -> builder.index(INDEX_NAME))).value();
+	}
+	
+	@SneakyThrows
+	private void createIndex() {
+		client.indices().create(builder -> builder.index(INDEX_NAME));
+	}
+	
+	@SneakyThrows
+	private void createSecurityRole() {
+		client.security().putRole(this::buildRequest);
+	}
+	
+	private PutRoleRequest.Builder buildRequest(PutRoleRequest.Builder requestBuilder) {
+		requestBuilder.name(PutRoleRequestDataTestFactory.NAME);
+		requestBuilder.indices(this::buildIndicesPrivilegesRequest);
+		return requestBuilder;
+	}
+	
+	private IndicesPrivileges.Builder buildIndicesPrivilegesRequest(IndicesPrivileges.Builder builder) {
+		builder.names(IndicesPrivilegesDataTestFactory.NAME);
+		builder.privileges(IndicesPrivilegesDataTestFactory.PRIVILEGES);
+		
+		return builder;
+	}
+	
+	@SneakyThrows
+	private boolean existsSecurityRole() {
+		return !client.security().getRole(builder -> builder.name(PutRoleRequestDataTestFactory.NAME)).result().isEmpty();
+	}
+	
+	@SneakyThrows
+	private void createSecurityUser() {
+		client.security().putUser(this::buildPutUserRequest);
+	}
+	
+	private PutUserRequest.Builder buildPutUserRequest(PutUserRequest.Builder builder) {
+		builder.username(PutUserRequestDataTestFactory.USERNAME);
+		builder.roles(PutUserRequestDataTestFactory.ROLES);
+		builder.password(PutUserRequestDataTestFactory.PASSWORD);
+		
+		return builder;
+	}
+	
+	@SneakyThrows
+	private boolean existsSecurityUser() {
+		return !client.security().getUser(builder -> builder.username(PutUserRequestDataTestFactory.USERNAME)).result().isEmpty();
+	}
 }
\ No newline at end of file

ozgcloud-elasticsearch-operator/src/test/java/de/ozgcloud/operator/common/elasticsearch/ElasticsearchRemoteServiceTest.java

@@ -9,8 +9,6 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
 
-import com.thedeanda.lorem.LoremIpsum;
-
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
 import de.ozgcloud.operator.IndicesPrivilegesDataTestFactory;
 import de.ozgcloud.operator.PutRoleRequestDataTestFactory;
@@ -24,39 +22,6 @@ class ElasticsearchRemoteServiceTest {
 	@Mock
 	private ElasticsearchClient client;
 	
-	@DisplayName("Create security role")
-	@Nested
-	class TestCreateIndex {
-		
-		@DisplayName("create exists request")
-		@Nested
-		class TestCreateExistsRequest {
-			
-			private static final String INDEX = LoremIpsum.getInstance().getFirstName();
-			
-			@Test
-			void shouldHaveIndex() {
-				var request = service.createExistsRequest(INDEX);
-				
-				assertThat(request.index()).containsExactly(INDEX);
-			}
-		}
-	}
-	
-	@DisplayName("Create get role request")
-	@Nested
-	class TestCreateGetRoleRequest {
-		
-		private static final String NAME = LoremIpsum.getInstance().getFirstName();
-			
-		@Test
-		void shouldHaveName() {
-			var request = service.createGetRoleRequest(NAME);
-			
-			assertThat(request.name()).containsExactly(NAME);
-		}
-	}
-	
 	@DisplayName("Create security role")
 	@Nested
 	class TestCreateSecurityRole {