Skip to content
Snippets Groups Projects
GroupMapperTest.java 8.39 KiB
Newer Older
  • Learn to ignore specific revisions
  • package de.ozgcloud.admin.keycloak;
    
    
    import static de.ozgcloud.admin.keycloak.GroupRepresentationTestFactory.*;
    
    import static org.assertj.core.api.Assertions.*;
    import static org.mockito.Mockito.*;
    
    
    import java.util.ArrayList;
    
    import java.util.List;
    import java.util.Map;
    import java.util.UUID;
    
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import org.junit.jupiter.params.ParameterizedTest;
    import org.junit.jupiter.params.provider.NullAndEmptySource;
    
    import org.junit.jupiter.params.provider.ValueSource;
    
    import org.keycloak.representations.idm.GroupRepresentation;
    import org.mapstruct.factory.Mappers;
    
    import org.mockito.ArgumentCaptor;
    import org.mockito.Captor;
    
    import org.mockito.InjectMocks;
    import org.mockito.Mock;
    
    import org.mockito.Spy;
    
    class GroupMapperTest {
    
    
    	@Mock
    	private KeycloakApiProperties properties;
    
    	@InjectMocks
    	private GroupMapper mapper = Mappers.getMapper(GroupMapper.class);
    
    	class TestFromGroupRepresentations {
    
    		private final GroupRepresentation groupRepresentation = GroupRepresentationTestFactory.create();
    
    		@Captor
    		private ArgumentCaptor<List<Group>> groupsCaptor;
    
    		void shouldMapFromGroupRepresentation() {
    			givenMappedGroupWithOrganisationsEinheitId();
    
    			callMapper();
    
    			verify(mapper).fromGroupRepresentation(groupRepresentation);
    
    		void shouldReturnListWithMappedGroupRepresentation() {
    			var group = givenMappedGroupWithOrganisationsEinheitId();
    
    			var groups = callMapper();
    
    			assertThat(groups).containsExactly(group);
    		}
    
    		@ParameterizedTest
    		@NullAndEmptySource
    		void shouldReturnEmptyList(String organisationsEinheitId) {
    			givenMappedGroupWithOrganisationsEinheitId(organisationsEinheitId);
    
    			var groups = callMapper();
    
    			assertThat(groups).isEmpty();
    
    		void shouldDeleteGroupsWithoutOrganisationsEinheitId() {
    			var group = givenMappedGroupWithOrganisationsEinheitId();
    
    			callMapper();
    
    			verify(mapper).deleteGroupsWithoutOrganisationsEinheitId(groupsCaptor.capture());
    			assertThat(groupsCaptor.getValue()).containsExactly(group);
    		}
    
    		private Group givenMappedGroupWithOrganisationsEinheitId() {
    			var group = GroupTestFactory.create();
    			doReturn(group).when(mapper).fromGroupRepresentation(groupRepresentation);
    			return group;
    		}
    
    		private void givenMappedGroupWithOrganisationsEinheitId(String id) {
    			var group = GroupTestFactory.createBuilder().organisationsEinheitId(id).build();
    			doReturn(group).when(mapper).fromGroupRepresentation(groupRepresentation);
    		}
    
    		private List<Group> callMapper() {
    			return mapper.fromGroupRepresentations(List.of(groupRepresentation));
    		}
    	}
    
    	@Nested
    	class TestDeleteGroupsWithoutOrganisationsEinheitId {
    
    		private final Group group = GroupTestFactory.create();
    		private final List<Group> groups = new ArrayList<>();
    
    		@BeforeEach
    		void init() {
    			groups.add(group);
    
    		void shouldCheckIfGroupHasOrganisationsEinheitId() {
    			mapper.deleteGroupsWithoutOrganisationsEinheitId(groups);
    
    			verify(mapper).isMissingOrganisationsEinheitId(group);
    		}
    
    		@Test
    		void shouldKeepGroupsWithOrganisationsEinheitId() {
    			doReturn(false).when(mapper).isMissingOrganisationsEinheitId(group);
    
    			mapper.deleteGroupsWithoutOrganisationsEinheitId(groups);
    
    			assertThat(groups).containsExactly(group);
    		}
    
    		@Test
    		void shouldRemoveGroupsWithoutOrganisationsEinheitId() {
    			doReturn(true).when(mapper).isMissingOrganisationsEinheitId(group);
    
    			mapper.deleteGroupsWithoutOrganisationsEinheitId(groups);
    
    			assertThat(groups).isEmpty();
    		}
    	}
    
    	@Nested
    	class TestIsMissingOrganisationsEinheitId {
    
    		@ParameterizedTest
    		@ValueSource(strings = " ")
    		@NullAndEmptySource
    		void shouldReturnTrueIfIdIsBlank(String organisationsEinheitId) {
    			var group = GroupTestFactory.createBuilder().organisationsEinheitId(organisationsEinheitId).build();
    
    			var isMissing = mapper.isMissingOrganisationsEinheitId(group);
    
    			assertThat(isMissing).isTrue();
    		}
    
    		@Test
    		void shouldReturnFalseIfIdIsSet() {
    			var isMissing = mapper.isMissingOrganisationsEinheitId(GroupTestFactory.create());
    
    			assertThat(isMissing).isFalse();
    
    		}
    	}
    
    	@Nested
    	class TestFromGroupRepresentation {
    
    		private final GroupRepresentation groupRepresentation = GroupRepresentationTestFactory.create();
    
    		@BeforeEach
    		void init() {
    
    			doReturn(GroupRepresentationTestFactory.ORGANISATIONS_EINHEIT_ID).when(mapper)
    
    					.getOrganisationsEinheitId(ATTRIBUTES);
    			doReturn(GroupRepresentationTestFactory.SUB_GROUP_ORGANISATIONS_EINHEIT_ID).when(mapper)
    					.getOrganisationsEinheitId(SUB_GROUP_ATTRIBUTES);
    
    		}
    
    		@Test
    		void shouldGetOrganisationsEinheitId() {
    			callMapper();
    
    			verify(mapper).getOrganisationsEinheitId(groupRepresentation.getAttributes());
    		}
    
    
    		@Test
    		void shouldSetId() {
    			var group = callMapper();
    
    			assertThat(group.getId()).isEqualTo(groupRepresentation.getId());
    		}
    
    
    		@Test
    		void shouldSetOrganisationsEinheitId() {
    			var group = callMapper();
    
    			assertThat(group.getOrganisationsEinheitId()).isEqualTo(GroupRepresentationTestFactory.ORGANISATIONS_EINHEIT_ID);
    		}
    
    		@Test
    		void shouldSetName() {
    			var group = callMapper();
    
    			assertThat(group.getName()).isEqualTo(GroupRepresentationTestFactory.NAME);
    		}
    
    		@Test
    
    		void shouldSetSubGroups() {
    
    			var group = callMapper();
    
    
    			assertThat(group.getSubGroups()).usingRecursiveFieldByFieldElementComparator()
    					.containsExactlyElementsOf(GroupTestFactory.create().getSubGroups());
    
    		}
    
    		private Group callMapper() {
    			return mapper.fromGroupRepresentation(groupRepresentation);
    		}
    	}
    
    	@Nested
    
    	class TestGetOrganisationsEinheitId {
    
    		void shouldReturnNullIfAttributesAreNull() {
    			var result = mapper.getOrganisationsEinheitId(null);
    
    			assertThat(result).isNull();
    
    		void shouldReturnNullIfAttributeIsAbsent() {
    			givenOrganisationsEinheitIdProperty();
    
    			var result = mapper.getOrganisationsEinheitId(Map.of("dummy-attribute", List.of("123")));
    
    			assertThat(result).isNull();
    
    		@Test
    		void shouldReturnOrganisationsEinheitId() {
    			givenOrganisationsEinheitIdProperty();
    			var value = GroupRepresentationTestFactory.ORGANISATIONS_EINHEIT_ID;
    			var result = mapper.getOrganisationsEinheitId(Map.of(ORGANIZATIONS_EINHEIT_ID_ATTRIBUTE, List.of(value)));
    
    			assertThat(result).isEqualTo(value);
    
    		@Test
    		void shouldReturnFirstValueIfMultipleAreAvailable() {
    			givenOrganisationsEinheitIdProperty();
    			var value = GroupRepresentationTestFactory.ORGANISATIONS_EINHEIT_ID;
    			var value2 = UUID.randomUUID().toString();
    
    			var result = mapper.getOrganisationsEinheitId(Map.of(ORGANIZATIONS_EINHEIT_ID_ATTRIBUTE, List.of(value, value2)));
    
    			assertThat(result).isEqualTo(value);
    
    	class TestToGroupRepresentation {
    
    		private final AddGroupData addGroupData = AddGroupDataTestFactory.create();
    
    			doReturn(ATTRIBUTES).when(mapper).getAttributes(addGroupData);
    
    		}
    
    		@Test
    		void shouldSetName() {
    			var groupRepresentation = callMapper();
    
    
    			assertThat(groupRepresentation.getName()).isEqualTo(addGroupData.getName());
    
    		}
    
    		@Test
    		void shouldNotSetSubGroups() {
    			var groupRepresentation = callMapper();
    
    			assertThat(groupRepresentation.getSubGroups()).isEmpty();
    		}
    
    		@Test
    		void shouldGetAttributes() {
    			callMapper();
    
    
    			verify(mapper).getAttributes(addGroupData);
    
    		}
    
    		@Test
    		void shouldSetAttributeOrganisationsEinheitId() {
    			var groupRepresentation = callMapper();
    
    			assertThat(groupRepresentation.getAttributes()).isNotNull().containsKey(ORGANIZATIONS_EINHEIT_ID_ATTRIBUTE);
    		}
    
    		private GroupRepresentation callMapper() {
    
    			return mapper.toGroupRepresentation(addGroupData);
    
    		}
    	}
    
    	@Nested
    	class TestGetAttributes {
    
    		@ParameterizedTest
    		@NullAndEmptySource
    		void shouldReturnEmptyMap(String organisationsEinheitId) {
    
    			var addGroupData = AddGroupDataTestFactory.createBuilder().organisationsEinheitId(organisationsEinheitId).build();
    
    			var attributes = mapper.getAttributes(addGroupData);
    
    
    			assertThat(attributes).isEmpty();
    		}
    
    		@Test
    		void shouldAddOrganisationsEinheitIdToAttributes() {
    			givenOrganisationsEinheitIdProperty();
    
    
    			var attributes = mapper.getAttributes(AddGroupDataTestFactory.create());
    
    
    			assertThat(attributes).hasSize(1).containsEntry(ORGANIZATIONS_EINHEIT_ID_ATTRIBUTE, List.of(GroupTestFactory.ORGANISATIONS_EINHEIT_ID));
    		}
    	}
    
    	private void givenOrganisationsEinheitIdProperty() {
    		when(properties.getOrganisationsEinheitIdKey()).thenReturn(ORGANIZATIONS_EINHEIT_ID_ATTRIBUTE);
    	}