Merge branch 'OZG-7474-weiterleitung-link' into OZG-7474-move-forwarding-package

alfa-service/src/main/java/de/ozgcloud/alfa/forwarding/ForwardingVorgangWithEingangProcessor.java

@@ -34,24 +34,28 @@ class ForwardingVorgangWithEingangProcessor implements RepresentationModelProces
 		Optional.ofNullable(model.getContent())
 				.ifPresent(vorgang -> model
 						.addIf(isForwardableByOzgCloud(vorgang), () -> buildForwardByOzgCloudLink(vorgang))
-						.addIf(isEinheitlicherAnsprechpartner(), () -> buildForwardByEmailLink(vorgang)));
+						.addIf(isForwardableByEmail(), () -> buildForwardByEmailLink(vorgang)));
 		return model;
 	}
 
 	boolean isForwardableByOzgCloud(VorgangWithEingang vorgang) {
-		return featureToggleProperties.isForwardByOzgCloudEnabled() && isStatusNeu(vorgang);
+		return featureToggleProperties.isForwardByOzgCloudEnabled() && isStatusNeu(vorgang) && isNotPoststelleOrEinheitlicherAnsprechpartner();
 	}
 
 	private boolean isStatusNeu(VorgangWithEingang vorgang) {
 		return vorgang.getStatus() == VorgangStatus.NEU;
 	}
 
+	boolean isNotPoststelleOrEinheitlicherAnsprechpartner() {
+		return userService.hasRole(UserRole.VERWALTUNG_POSTSTELLE) || userService.hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER);
+	}
+
 	private Link buildForwardByOzgCloudLink(VorgangWithEingang vorgang) {
 		return linkTo(methodOn(CommandController.CommandByRelationController.class).createCommand(vorgang.getId(), vorgang.getId(),
 				vorgang.getVersion(), null)).withRel(REL_FORWARD_BY_OZGCLOUD);
 	}
 
-	private boolean isEinheitlicherAnsprechpartner() {
+	boolean isForwardableByEmail() {
 		return userService.hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER);
 	}
 

alfa-service/src/test/java/de/ozgcloud/alfa/forwarding/ForwardingVorgangWithEingangProcessorTest.java

@@ -5,12 +5,12 @@ import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
 import org.junit.jupiter.params.provider.EnumSource.Mode;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
@@ -22,7 +22,6 @@ import de.ozgcloud.alfa.common.FeatureToggleProperties;
 import de.ozgcloud.alfa.common.command.CommandController.CommandByRelationController;
 import de.ozgcloud.alfa.common.user.CurrentUserService;
 import de.ozgcloud.alfa.common.user.UserRole;
-import de.ozgcloud.alfa.vorgang.Vorgang;
 import de.ozgcloud.alfa.vorgang.Vorgang.VorgangStatus;
 import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
 import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
@@ -42,6 +41,8 @@ class ForwardingVorgangWithEingangProcessorTest {
 	@Nested
 	class TestProcess {
 
+		private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
 		@Test
 		void shouldReturnSameModelOnEmptyEntity() {
 			EntityModel<VorgangWithEingang> inputModel = when(mock(EntityModel.class).getContent()).thenReturn(null).getMock();
@@ -53,7 +54,7 @@ class ForwardingVorgangWithEingangProcessorTest {
 
 		@Test
 		void shouldReturnSameModel() {
-			var inputModel = EntityModel.of(VorgangWithEingangTestFactory.create());
+			var inputModel = EntityModel.of(vorgang);
 
 			var model = processor.process(inputModel);
 
@@ -63,10 +64,10 @@ class ForwardingVorgangWithEingangProcessorTest {
 		@Nested
 		class TestForwardByOzgCloudLink {
 
-			private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
-
 			@Test
 			void shouldCallIsForwardableByOzgCloud() {
+				doReturn(false).when(processor).isForwardableByOzgCloud(any());
+
 				processor.process(EntityModel.of(vorgang));
 
 				verify(processor).isForwardableByOzgCloud(vorgang);
@@ -74,6 +75,7 @@ class ForwardingVorgangWithEingangProcessorTest {
 
 			@Nested
 			class TestOnIsNotForwardableByOzgCloud {
+
 				@BeforeEach
 				void givenIsNotForwardableByOzgCloud() {
 					doReturn(false).when(processor).isForwardableByOzgCloud(any());
@@ -89,6 +91,7 @@ class ForwardingVorgangWithEingangProcessorTest {
 
 			@Nested
 			class TestOnIsForwardableByOzgCloud {
+
 				@BeforeEach
 				void givenIsNotForwardableByOzgCloud() {
 					doReturn(true).when(processor).isForwardableByOzgCloud(any());
@@ -109,40 +112,52 @@ class ForwardingVorgangWithEingangProcessorTest {
 		}
 
 		@Nested
-		class TestForwardingLink {
+		class TestForwardByEmailLink {
 
-			@DisplayName("should NOT be present in other Role then EA")
-			@ParameterizedTest
-			@EnumSource
-			void shouldNotBePresentWithoutRole(Vorgang.VorgangStatus status) {
-				when(userService.hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER)).thenReturn(false);
+			@Test
+			void shouldCallIsForwardableByEmail() {
+				doReturn(false).when(processor).isForwardableByEmail();
 
-				var link = processor.process(buildVorgangInStatus(status)).getLink(ForwardingVorgangWithEingangProcessor.REL_FORWARD_BY_EMAIL);
+				processor.process(EntityModel.of(vorgang));
 
-				assertThat(link).isEmpty();
+				verify(processor).isForwardableByEmail();
 			}
 
-			@DisplayName("with role EinheitlicherAnsprechpartner")
 			@Nested
-			class TestWithRoleEinheitlicherAnsprechpartner {
+			class TestOnIsNotForwardableByEmail {
+
 				@BeforeEach
-				void init() {
-					when(userService.hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER)).thenReturn(true);
+				void givenIsNotForwardableByEmail() {
+					doReturn(false).when(processor).isForwardableByEmail();
 				}
 
-				@DisplayName("should be present in any Status")
-				@ParameterizedTest
-				@EnumSource()
-				void shouldBePresent(VorgangStatus status) {
-					var link = processor.process(buildVorgangInStatus(status)).getLink(ForwardingVorgangWithEingangProcessor.REL_FORWARD_BY_EMAIL);
+				@Test
+				void shouldNotAddLink() {
+					var model = processor.process(EntityModel.of(vorgang));
 
-					assertThat(link).isPresent().get().extracting(Link::getHref)
-							.isEqualTo("/api/forwardings?vorgangId=" + VorgangHeaderTestFactory.ID);
+					assertThat(model.getLink(ForwardingVorgangWithEingangProcessor.REL_FORWARD_BY_EMAIL)).isEmpty();
 				}
 			}
 
-			private EntityModel<VorgangWithEingang> buildVorgangInStatus(VorgangStatus status) {
-				return EntityModel.of(VorgangWithEingangTestFactory.createBuilder().status(status).build());
+			@Nested
+			class TestOnIsForwardableByEmail {
+
+				@BeforeEach
+				void givenIsForwardableByEmail() {
+					doReturn(true).when(processor).isForwardableByEmail();
+				}
+
+				@Test
+				void shouldAddLink() {
+					var expectedHref = UriComponentsBuilder.fromUriString(ForwardingController.LIST_PATH)
+							.queryParam(ForwardingController.PARAM_VORGANG_ID, VorgangHeaderTestFactory.ID).build().toString();
+
+					var model = processor.process(EntityModel.of(vorgang));
+
+					assertThat(model.getLink(ForwardingVorgangWithEingangProcessor.REL_FORWARD_BY_EMAIL)).get()
+							.extracting(Link::getHref)
+							.isEqualTo(expectedHref);
+				}
 			}
 		}
 	}
@@ -167,6 +182,16 @@ class ForwardingVorgangWithEingangProcessorTest {
 
 				assertThat(forwardableByOzgCloud).isFalse();
 			}
+
+			@ParameterizedTest
+			@EnumSource
+			void shouldNotCallIsNotPoststelleOrEinheitlicherAnsprechpartner(VorgangStatus status) {
+				var vorgang = VorgangWithEingangTestFactory.createBuilder().status(status).build();
+
+				processor.isForwardableByOzgCloud(vorgang);
+
+				verify(processor, never()).isNotPoststelleOrEinheitlicherAnsprechpartner();
+			}
 		}
 
 		@Nested
@@ -177,6 +202,8 @@ class ForwardingVorgangWithEingangProcessorTest {
 				when(featureToggleProperties.isForwardByOzgCloudEnabled()).thenReturn(true);
 			}
 
+			@Nested
+			class TestOnVorgangNotNeu {
 				@ParameterizedTest
 				@EnumSource(mode = Mode.EXCLUDE, names = { "NEU" })
 				void shouldReturnFalseOnVorgangStatusNotNeu(VorgangStatus status) {
@@ -187,14 +214,97 @@ class ForwardingVorgangWithEingangProcessorTest {
 					assertThat(forwardableByOzgCloud).isFalse();
 				}
 
+				@ParameterizedTest
+				@EnumSource(mode = Mode.EXCLUDE, names = { "NEU" })
+				void shouldNotCallIsNotPoststelleOrEinheitlicherAnsprechpartner(VorgangStatus status) {
+					var vorgang = VorgangWithEingangTestFactory.createBuilder().status(status).build();
+
+					processor.isForwardableByOzgCloud(vorgang);
+
+					verify(processor, never()).isNotPoststelleOrEinheitlicherAnsprechpartner();
+				}
+			}
+
+			@Nested
+			class TestOnVorgangIsNeu {
+
+				private final VorgangWithEingang newVorgang = VorgangWithEingangTestFactory.createBuilder().status(VorgangStatus.NEU).build();
+
 				@Test
-			void shouldReturnTrueOnVorgangStatusNeu() {
-				var vorgang = VorgangWithEingangTestFactory.createBuilder().status(VorgangStatus.NEU).build();
+				void shouldCallIsNotPoststelleOrEinheitlicherAnsprechpartner() {
+					processor.isForwardableByOzgCloud(newVorgang);
 
-				var forwardableByOzgCloud = processor.isForwardableByOzgCloud(vorgang);
+					verify(processor).isNotPoststelleOrEinheitlicherAnsprechpartner();
+				}
+
+				@ParameterizedTest
+				@ValueSource(booleans = { true, false })
+				void shouldReturnValueOfisNotPoststelleOrEinheitlicherAnsprechpartner(boolean isNotPoststelleOrEinheitlicherAnsprechpartner) {
+					doReturn(isNotPoststelleOrEinheitlicherAnsprechpartner).when(processor).isNotPoststelleOrEinheitlicherAnsprechpartner();
+
+					var forwardableByOzgCloud = processor.isForwardableByOzgCloud(newVorgang);
+
+					assertThat(forwardableByOzgCloud).isEqualTo(isNotPoststelleOrEinheitlicherAnsprechpartner);
+				}
+			}
+		}
+	}
+
+	@Nested
+	class TestIsNotPoststelleOrEinheitlicherAnsprechpartner {
+
+		private static final String UNKOWN_ROLE = "UNKOWN_ROLE";
+
+		@BeforeEach
+		void mock() {
+			when(userService.hasRole(any())).thenAnswer(invocation -> {
+				var role = invocation.getArgument(0, String.class);
+				return role == UserRole.EINHEITLICHER_ANSPRECHPARTNER || role == UserRole.VERWALTUNG_POSTSTELLE;
+			});
+		}
 
-				assertThat(forwardableByOzgCloud).isTrue();
+		@Test
+		void shouldCallUserServiceForCurrentRole() {
+			processor.isForwardableByEmail();
+
+			verify(userService).hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER);
+		}
+
+		@ParameterizedTest
+		@ValueSource(strings = { UserRole.EINHEITLICHER_ANSPRECHPARTNER, UserRole.VERWALTUNG_POSTSTELLE })
+		void shouldReturnFalse(String role) {
+			var isNotPoststelleOrEinheitlicherAnsprechpartner = processor.isNotPoststelleOrEinheitlicherAnsprechpartner();
+
+			assertThat(isNotPoststelleOrEinheitlicherAnsprechpartner).isTrue();
+		}
+
+		@ParameterizedTest
+		@ValueSource(strings = { UserRole.VERWALTUNG_LOESCHEN, UserRole.VERWALTUNG_USER, UNKOWN_ROLE })
+		void shouldReturnTrue(String role) {
+			var isNotPoststelleOrEinheitlicherAnsprechpartner = processor.isNotPoststelleOrEinheitlicherAnsprechpartner();
+
+			assertThat(isNotPoststelleOrEinheitlicherAnsprechpartner).isTrue();
+		}
 	}
+
+	@Nested
+	class TestIsForwardableByEmail {
+
+		@Test
+		void shouldCallUserServiceForCurrentRole() {
+			processor.isForwardableByEmail();
+
+			verify(userService).hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER);
+		}
+
+		@ParameterizedTest
+		@ValueSource(booleans = { true, false })
+		void shouldReturnIsEinheitlicherAnsprechpartner(boolean isEinheitlicherAnsprechpartner) {
+			when(userService.hasRole(any())).thenReturn(isEinheitlicherAnsprechpartner);
+
+			var isForwardableByEmail = processor.isForwardableByEmail();
+
+			assertThat(isForwardableByEmail).isEqualTo(isEinheitlicherAnsprechpartner);
 		}
 	}
 }