OZG-6748 Cleanup VorgangService::createVorgang

router/src/main/java/de/ozgcloud/eingang/router/VorgangService.java

@@ -40,12 +40,12 @@ public class VorgangService {
 
 	private final VorgangRemoteService remoteService;
 
-	public List<String> createVorgangs(FormData formData) {
+	public String createVorgang(FormData formData) {
 		var preparedFormData = preserveConsistency(formData);
 		var organisationseinheitIds = getOrganisationsEinheitIds(formData);
 		return organisationseinheitIds.isEmpty()
-				? List.of(createVorgangOnMissingZustaendigeStelle(preparedFormData))
-				: createMultipleVorgangs(preparedFormData, organisationseinheitIds);
+				? createVorgangOnMissingZustaendigeStelle(preparedFormData)
+				: createMultipleVorgangs(preparedFormData, organisationseinheitIds).getFirst();
 	}
 
 	String createVorgangOnMissingZustaendigeStelle(FormData formData) {

router/src/test/java/de/ozgcloud/eingang/router/VorgangServiceTest.java

@@ -57,12 +57,11 @@ class VorgangServiceTest {
 	@Mock
 	private VorgangRemoteService remoteService;
 
-	private static final String VORGANG_ID_2 = "vorgangId2";
 	private static final String ORGANISATIONSEINHEIT_ID_2 = "08150816";
 
-	public static final List<String> ORGANISATIONSEINHEIT_IDS = List.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID,
-			ORGANISATIONSEINHEIT_ID_2);
-
+	@DisplayName("Create vorgang")
+	@Nested
+	class TestCreateVorgangs {
 		private FormData formData;
 		private FormData preservedFormData;
 
@@ -74,41 +73,91 @@ class VorgangServiceTest {
 							.organisationseinheitenId(ORGANISATIONSEINHEIT_ID_2)
 							.build())
 					.build();
+			doReturn(preservedFormData).when(service).preserveConsistency(any());
 		}
 
-	@DisplayName("Create vorgangs")
-	@Nested
-	class TestCreateVorgangs {
+		@DisplayName("should call preserve consistency")
+		@Test
+		void shouldCallPreserveConsistency() {
+			mockOrganisationseinheitId();
 
-		@BeforeEach
-		void mockEingangMapper() {
-			doReturn(preservedFormData).when(service).preserveConsistency(formData);
+			createVorgang();
+
+			verify(service).preserveConsistency(eq(formData));
+		}
+
+		@DisplayName("should call get organisationseinheit ids")
+		@Test
+		void shouldCallGetOrganisationseinheitIds() {
+			mockOrganisationseinheitId();
+
+			createVorgang();
+
+			verify(service).getOrganisationsEinheitIds(eq(formData));
 		}
 
-		@DisplayName("should return multiple vorgang ids for each organisationseinheit")
+		@DisplayName("should call create multiple vorgangs")
 		@Test
-		void shouldReturnMultipleVorgangIdsForEachOrganisationseinheit() {
-			doReturn(ORGANISATIONSEINHEIT_IDS).when(service).getOrganisationsEinheitIds(formData);
-			doReturn(List.of(VORGANG_ID, VORGANG_ID_2)).when(service).createMultipleVorgangs(preservedFormData, ORGANISATIONSEINHEIT_IDS);
+		void shouldCallCreateMultipleVorgangs() {
+			var organisationseinheitIds = List.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID, ORGANISATIONSEINHEIT_ID_2);
+			mockOrganisationseinheitIds(organisationseinheitIds);
 
-			var vorgangIds = createVorgangs();
+			createVorgang();
 
-			assertThat(vorgangIds).containsExactly(VORGANG_ID, VORGANG_ID_2);
+			verify(service).createMultipleVorgangs(
+					eq(preservedFormData),
+					eq(organisationseinheitIds));
+		}
+
+		@DisplayName("should return first vorgang id with multiple organisationseinheits")
+		@Test
+		void shouldReturnFirstVorgangIdWithMultipleOrganisationseinheits() {
+			var organisationseinheitIds = List.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID, ORGANISATIONSEINHEIT_ID_2);
+			mockOrganisationseinheitIds(organisationseinheitIds);
+
+			var vorgangIds = createVorgang();
+
+			assertThat(vorgangIds).isEqualTo(VORGANG_ID);
+		}
+
+		private void mockOrganisationseinheitId() {
+			doReturn(List.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID)).when(service).getOrganisationsEinheitIds(any());
+			doReturn(List.of(VORGANG_ID)).when(service).createMultipleVorgangs(any(), any());
+		}
+
+		private void mockOrganisationseinheitIds(List<String> organisationseinheitIds) {
+			doReturn(organisationseinheitIds).when(service)
+					.getOrganisationsEinheitIds(any());
+			doReturn(List.of(VORGANG_ID, "otherId")).when(service).createMultipleVorgangs(any(), any());
+		}
+
+		@DisplayName("should call create vorgang on missing zustaendige stelle if organisationseinheit is missing")
+		@Test
+		void shouldCallCreateVorgangOnMissingZustaendigeStelleIfOrganisationseinheitIsMissing() {
+			mockMissingOrganisationseinheitIds();
+
+			createVorgang();
+
+			verify(service).createVorgangOnMissingZustaendigeStelle(eq(preservedFormData));
 		}
 
 		@DisplayName("should return single vorgang id if organisationseinheit is missing")
 		@Test
 		void shouldReturnSingleVorgangIdIfOrganisationseinheitIsMissing() {
-			doReturn(emptyList()).when(service).getOrganisationsEinheitIds(formData);
-			doReturn(VORGANG_ID).when(service).createVorgangOnMissingZustaendigeStelle(preservedFormData);
+			mockMissingOrganisationseinheitIds();
+
+			var firstVorgangId = createVorgang();
 
-			var vorgangIds = createVorgangs();
+			assertThat(firstVorgangId).isEqualTo(VORGANG_ID);
+		}
 
-			assertThat(vorgangIds).containsExactly(VORGANG_ID);
+		private void mockMissingOrganisationseinheitIds() {
+			doReturn(emptyList()).when(service).getOrganisationsEinheitIds(any());
+			doReturn(VORGANG_ID).when(service).createVorgangOnMissingZustaendigeStelle(any());
 		}
 
-		private List<String> createVorgangs() {
-			return service.createVorgangs(formData);
+		private String createVorgang() {
+			return service.createVorgang(formData);
 		}
 	}
 
@@ -118,11 +167,22 @@ class VorgangServiceTest {
 		@Mock
 		private FormData formData;
 
+		@BeforeEach
+		void mock() {
+			when(remoteService.createVorgang(any(), any())).thenReturn(VORGANG_ID);
+		}
+
+		@DisplayName("should call create vorgang")
+		@Test
+		void shouldCallCreateVorgang() {
+			service.createVorgangOnMissingZustaendigeStelle(formData);
+
+			verify(remoteService).createVorgang(formData, Optional.empty());
+		}
+
 		@DisplayName("should return")
 		@Test
 		void shouldReturn() {
-			when(remoteService.createVorgang(formData, Optional.empty())).thenReturn(VORGANG_ID);
-
 			var vorgangId = service.createVorgangOnMissingZustaendigeStelle(formData);
 
 			assertThat(vorgangId).isEqualTo(VORGANG_ID);
@@ -132,24 +192,54 @@ class VorgangServiceTest {
 	@DisplayName("create multiple vorgangs")
 	@Nested
 	class TestCreateMultipleVorgangs {
+
+		private static final String VORGANG_ID_2 = "vorgangId2";
+		private static final List<String> ORGANISATIONSEINHEIT_IDS = List.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID,
+				ORGANISATIONSEINHEIT_ID_2);
+
 		@Mock
 		private FormData formData;
 
+		@BeforeEach
+		void mock() {
+			when(remoteService.createVorgang(any(), any()))
+					.thenReturn(VORGANG_ID)
+					.thenReturn(VORGANG_ID_2);
+		}
+
+		@DisplayName("should call create vorgang twice")
+		@Test
+		void shouldCallCreateVorgangTwice() {
+			service.createMultipleVorgangs(formData, ORGANISATIONSEINHEIT_IDS);
+
+			verify(remoteService).createVorgang(formData, Optional.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID));
+			verify(remoteService).createVorgang(formData, Optional.of(ORGANISATIONSEINHEIT_ID_2));
+		}
+
 		@DisplayName("should return")
 		@Test
 		void shouldReturn() {
-			when(remoteService.createVorgang(formData, Optional.of(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEIT_ID))).thenReturn(VORGANG_ID);
-			when(remoteService.createVorgang(formData, Optional.of(ORGANISATIONSEINHEIT_ID_2))).thenReturn(VORGANG_ID_2);
-
 			var vorgangIds = service.createMultipleVorgangs(formData, ORGANISATIONSEINHEIT_IDS);
 
-			assertThat(vorgangIds).containsExactly(VORGANG_ID, VORGANG_ID_2);
+			assertThat(vorgangIds).containsExactlyInAnyOrder(VORGANG_ID, VORGANG_ID_2);
 		}
 	}
 
 	@DisplayName("get organisationseinheit ids")
 	@Nested
 	class TestGetOrganisationseinheitIds {
+
+		private FormData preservedFormData;
+
+		@BeforeEach
+		void mock() {
+			preservedFormData = FormDataTestFactory.createBuilder()
+					.zustaendigeStelle(ZustaendigeStelleTestFactory.createBuilder()
+							.organisationseinheitenId(ORGANISATIONSEINHEIT_ID_2)
+							.build())
+					.build();
+		}
+
 		@DisplayName("should return")
 		@Test
 		void shouldReturn() {

semantik-adapter/src/main/java/de/ozgcloud/eingang/semantik/SemantikAdapter.java

@@ -34,7 +34,6 @@ import de.ozgcloud.eingang.semantik.enginebased.EngineBasedSemantikAdapter;
 import de.ozgcloud.eingang.semantik.formbased.FormBasedSemantikAdapter;
 import lombok.extern.log4j.Log4j2;
 
-
 @Log4j2
 @Service
 public class SemantikAdapter {
@@ -50,7 +49,7 @@ public class SemantikAdapter {
 		formData = parseByEngineAdapter(formData);
 		formData = parseByFormAdapter(formData);
 
-		return vorgangService.createVorgangs(formData).getFirst();
+		return vorgangService.createVorgang(formData);
 	}
 
 	private FormData parseByEngineAdapter(FormData formData) {

semantik-adapter/src/test/java/de/ozgcloud/eingang/semantik/SemantikAdapterTest.java

@@ -99,7 +99,7 @@ class SemantikAdapterTest {
 			doReturn(List.of(engineAdapter)).when(adapter).getResponsibleEngineAdapters(formData);
 			when(engineAdapter.parseFormData(any())).thenReturn(engineAdapterResponse);
 			when(formAdapter.parseFormData(any())).thenReturn(formAdapterResponse);
-			when(vorgangService.createVorgangs(formAdapterResponse)).thenReturn(List.of(VORGANG_ID, "otherId"));
+			when(vorgangService.createVorgang(any())).thenReturn(VORGANG_ID);
 		}
 
 		@Test
@@ -127,7 +127,7 @@ class SemantikAdapterTest {
 		void shouldCallVorgangRemoteService() {
 			adapter.processFormData(formData);
 
-			verify(vorgangService).createVorgangs(formAdapterResponse);
+			verify(vorgangService).createVorgang(formAdapterResponse);
 		}
 
 		@DisplayName("should return first vorgang id")