KOP-2949 Catch RuntimeExceptions, defensively

src/main/java/de/ozgcloud/eingang/semantik/enginebased/afm/AfmEngineBasedAdapter.java

@@ -32,7 +32,9 @@ import de.ozgcloud.eingang.common.formdata.FormData;
 import de.ozgcloud.eingang.common.formdata.FormDataUtils;
 import de.ozgcloud.eingang.semantik.enginebased.EngineBasedSemantikAdapter;
 import de.ozgcloud.eingang.semantik.enginebased.afm.intelliform.IntelliFormRepresentationAdapter;
+import lombok.extern.log4j.Log4j2;
 
+@Log4j2
 @Component
 @RequiredArgsConstructor
 public class AfmEngineBasedAdapter implements EngineBasedSemantikAdapter {
@@ -46,14 +48,23 @@ public class AfmEngineBasedAdapter implements EngineBasedSemantikAdapter {
 		var processedFormData = intelliFormRepresentationAdapter.adaptByRepresentations(formData);
 
 		for (var mapper : mappers) {
-			processedFormData = mapper.parseFormData(processedFormData);
+			processedFormData = applyFormDataMapperAndCatchException(mapper, processedFormData);
 		}
 
 		return removeProcessedData(processedFormData);
 	}
 
+	private FormData applyFormDataMapperAndCatchException(AfmEngineBasedMapper mapper, FormData formData) {
+		try {
+			return mapper.parseFormData(formData);
+		} catch (RuntimeException e) {
+			LOG.error("Error while parsing form data with mapper {}", mapper.getClass().getSimpleName(), e);
+			return formData;
+		}
+	}
+
 
-	private FormData removeProcessedData(FormData formData) {
+	FormData removeProcessedData(FormData formData) {
 		return FormDataUtils.from(formData)
 				.remove(AfmAntragstellerMapper.POSTFACH_ID)
 				.build();

src/test/java/de/ozgcloud/eingang/semantik/enginebased/afm/AfmEngineBasedAdapterTest.java

@@ -26,7 +26,7 @@ package de.ozgcloud.eingang.semantik.enginebased.afm;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -39,7 +39,7 @@ import org.mockito.Spy;
 import org.springframework.test.util.ReflectionTestUtils;
 
 import de.ozgcloud.eingang.common.formdata.FormData;
-import de.ozgcloud.eingang.common.formdata.FormHeader;
+import de.ozgcloud.eingang.common.formdata.FormDataTestFactory;
 import de.ozgcloud.eingang.semantik.enginebased.afm.intelliform.IntelliFormRepresentationAdapter;
 
 class AfmEngineBasedAdapterTest {
@@ -47,8 +47,6 @@ class AfmEngineBasedAdapterTest {
 	@Spy
 	@InjectMocks
 	private AfmEngineBasedAdapter adapter;
-	@Mock
-	private AfmEngineBasedMapper mapper;
 
 	@Mock
 	private IntelliFormRepresentationAdapter intelliFormRepresentationAdapters;
@@ -56,50 +54,144 @@ class AfmEngineBasedAdapterTest {
 	@DisplayName("Parse form data")
 	@Nested
 	class TestParseFromData {
-		private static final String VORGANG_NUMMER = "AAAA-1234";
-
-		private final Map<String, Object> formDataMap = Map.of(AfmAntragstellerMapper.POSTFACH_ID, "postfachIdValue");
-		private final FormData formData = FormData.builder()
-				.header(FormHeader.builder()
-						.vorgangNummer(VORGANG_NUMMER)
-						.build()
-				)
-				.formData(formDataMap)
-				.build();
+		@Mock
+		private AfmEngineBasedMapper mapper0;
+
+		@Mock
+		private AfmEngineBasedMapper mapper1;
+
+		@Mock
+		private FormData formData0;
+
+		@Mock
+		private FormData formData1;
+
+		@Mock
+		private FormData formData2;
+
+		@Mock
+		private FormData formData3;
+
+		@Mock
+		private FormData formData4;
+
+		@DisplayName("without exception")
+		@Nested
+		class TestWithoutException {
+
 
-		private final FormData processedFormData = FormData.builder()
-				.formData(formDataMap)
-				.build();
 
 		@BeforeEach
 		void mock() {
-			ReflectionTestUtils.setField(adapter, "mappers", Collections.singletonList(mapper));
+			ReflectionTestUtils.setField(adapter, "mappers", List.of(mapper0, mapper1));
+
+			when(intelliFormRepresentationAdapters.adaptByRepresentations(any())).thenReturn(formData1);
+			when(mapper0.parseFormData(any())).thenReturn(formData2);
+			when(mapper1.parseFormData(any())).thenReturn(formData3);
+			doReturn(formData4).when(adapter).removeProcessedData(any());
+		}
+
+		@DisplayName("should call adaptByRepresentations")
+		@Test
+		void shouldCallAdaptByRepresentations() {
+			parseFormData();
+
+			verify(intelliFormRepresentationAdapters).adaptByRepresentations(formData0);
+		}
+
+		@DisplayName("should call first mapper")
+		@Test
+		void shouldCallFirstMapper() {
+			parseFormData();
+
+			verify(mapper0).parseFormData(formData1);
+		}
+
+		@DisplayName("should call second mapper")
+		@Test
+		void shouldCallSecondMapper() {
+			parseFormData();
+
+			verify(mapper1).parseFormData(formData2);
+		}
+
+		@DisplayName("should call removeProcessedData")
+		@Test
+		void shouldCallRemoveProcessedData() {
+			parseFormData();
 
-			when(mapper.parseFormData(processedFormData)).thenReturn(processedFormData);
-			when(intelliFormRepresentationAdapters.adaptByRepresentations(formData)).thenReturn(processedFormData);
+			verify(adapter).removeProcessedData(formData3);
 		}
 
+		@DisplayName("should return")
 		@Test
-		void shouldCallRepresentationAdapter() {
-			adapter.parseFormData(formData);
+		void shouldReturn() {
+			var result = parseFormData();
+
+			assertThat(result).isEqualTo(formData4);
+		}
+
+		}
+
+		@DisplayName("with exception")
+		@Nested
+		class TestWithException {
+			@BeforeEach
+			void mock() {
+				ReflectionTestUtils.setField(adapter, "mappers", List.of(mapper0, mapper1));
 
-			verify(intelliFormRepresentationAdapters).adaptByRepresentations(formData);
+				when(intelliFormRepresentationAdapters.adaptByRepresentations(any())).thenReturn(formData1);
+				when(mapper0.parseFormData(any())).thenReturn(formData2);
+				when(mapper1.parseFormData(any())).thenThrow(new RuntimeException());
+				doReturn(formData4).when(adapter).removeProcessedData(any());
 			}
 
+			@DisplayName("should call removeProcessedData with old formData")
 			@Test
-		void shouldCallMappers() {
-			adapter.parseFormData(formData);
+			void shouldCallRemoveProcessedDataWithOldFormData() {
+				parseFormData();
 
-			verify(mapper).parseFormData(processedFormData);
+				verify(adapter).removeProcessedData(formData2);
 			}
 
+			@DisplayName("should return")
 			@Test
-		void shouldRemovePostfachId() {
-			var mappedFormData = adapter.parseFormData(formData);
+			void shouldReturn() {
+				var result = parseFormData();
+
+				assertThat(result).isEqualTo(formData4);
+			}
+		}
 
-			assertThat(mappedFormData.getFormData()).doesNotContainKey(AfmAntragstellerMapper.POSTFACH_ID);
+		FormData parseFormData() {
+			return adapter.parseFormData(formData0);
 		}
+	}
+
+	@DisplayName("remove processed data")
+	@Nested
+	class TestRemoveProcessedData {
 
+		private final FormData formData = FormDataTestFactory.createBuilder()
+				.formData(Map.of(
+						AfmAntragstellerMapper.POSTFACH_ID, "postfachIdValue",
+						"key", "value"
+				))
+				.build();
+
+		private final FormData outputFormData = FormDataTestFactory.createBuilder()
+				.formData(Map.of(
+						"key", "value"
+				))
+				.build();
+
+		@DisplayName("should return without postfachId")
+		@Test
+		void shouldReturnWithoutPostfachId() {
+			var mappedFormData = adapter.removeProcessedData(formData);
+
+			assertThat(mappedFormData).usingRecursiveComparison().isEqualTo(outputFormData);
+		}
 	}
 
 }