OZG-7038 removed static utils class

archive-manager-server/src/main/java/de/ozgcloud/archive/common/xta/XtaConfiguration.java

@@ -2,6 +2,10 @@ package de.ozgcloud.archive.common.xta;
 
 import java.io.IOException;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -58,4 +62,9 @@ class XtaConfiguration {
 	ObjectMapper objectMapper() {
 		return new ObjectMapper();
 	}
+
+	@Bean
+	DocumentBuilder documentBuilder() throws ParserConfigurationException {
+		return DocumentBuilderFactory.newDefaultInstance().newDocumentBuilder();
+	}
 }

archive-manager-server/src/main/java/de/ozgcloud/archive/common/xta/XtaFileXmlUtils.java → archive-manager-server/src/main/java/de/ozgcloud/archive/common/xta/XtaFileParser.java

@@ -3,42 +3,39 @@ package de.ozgcloud.archive.common.xta;
 import java.io.IOException;
 
 import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 
+import org.springframework.stereotype.Component;
 import org.w3c.dom.Document;
 import org.xml.sax.SAXException;
 
 import de.ozgcloud.xta.client.model.XtaFile;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
 
 @Log4j2
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public class XtaFileXmlUtils {
+@RequiredArgsConstructor
+@Component
+public class XtaFileParser {
 
-	public static boolean isType(XtaFile file, XtaFileType type) {
+	private final DocumentBuilder documentBuilder;
+
+	public boolean isType(XtaFile file, XtaFileType type) {
 		try {
-			var doc = XtaFileXmlUtils.parse(file);
-			return type.getTypeStr().equals(XtaFileXmlUtils.getRootTagName(doc));
+			var doc = parse(file);
+			return type.getTypeStr().equals(getRootTagName(doc));
 		} catch (Exception e) {
 			LOG.warn("Error parsing xta file.", e);
 			return false;
 		}
 	}
 
-	private static String getRootTagName(Document doc) {
-		return doc.getDocumentElement().getTagName();
-	}
-
-	static Document parse(XtaFile file) throws SAXException, IOException, ParserConfigurationException {
-		var document = XtaFileXmlUtils.createDocumentBuilder().parse(file.content().getDataSource().getInputStream());
+	Document parse(XtaFile file) throws SAXException, IOException {
+		var document = documentBuilder.parse(file.content().getDataSource().getInputStream());
 		document.getDocumentElement().normalize();
 		return document;
 	}
 
-	private static DocumentBuilder createDocumentBuilder() throws ParserConfigurationException {
-		return DocumentBuilderFactory.newDefaultInstance().newDocumentBuilder();
+	private String getRootTagName(Document doc) {
+		return doc.getDocumentElement().getTagName();
 	}
 }
\ No newline at end of file

archive-manager-server/src/main/java/de/ozgcloud/archive/quittung/QuittungService.java

@@ -10,8 +10,8 @@ import de.ozgcloud.archive.common.command.ArchiveManagerCommand;
 import de.ozgcloud.archive.common.command.CommandOrder;
 import de.ozgcloud.archive.common.command.CommandService;
 import de.ozgcloud.archive.common.xta.XtaFileHelper;
+import de.ozgcloud.archive.common.xta.XtaFileParser;
 import de.ozgcloud.archive.common.xta.XtaFileType;
-import de.ozgcloud.archive.common.xta.XtaFileXmlUtils;
 import de.ozgcloud.archive.common.xta.XtaImportConfirmationHandler.XtaAbgabeAdapter;
 import de.ozgcloud.archive.common.xta.XtaService;
 import de.ozgcloud.command.Command;
@@ -29,6 +29,7 @@ class QuittungService {
 
 	private final XtaService xtaService;
 	private final XtaFileHelper xtaFileHelper;
+	private final XtaFileParser xtaFileParser;
 
 	private final CommandService commandService;
 
@@ -45,7 +46,7 @@ class QuittungService {
 	}
 
 	boolean isImportConfirmation(XtaFile xtaFile) {
-		return XtaFileXmlUtils.isType(xtaFile, XtaFileType.IMPORT_CONFIRMATION);
+		return xtaFileParser.isType(xtaFile, XtaFileType.IMPORT_CONFIRMATION);
 	}
 
 	void handleAbgabe(XtaAbgabeAdapter abgabeHandler) {

archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/AbgabeImportBestaetigen0402TestFactory.java

@@ -29,6 +29,6 @@ public class AbgabeImportBestaetigen0402TestFactory {
 
 	@SneakyThrows
 	public static Document createAsDocument() {
-		return XtaFileXmlUtils.parse(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH));
+		return DocumentTestFactory.createFrom(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH));
 	}
 }
\ No newline at end of file

archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/DocumentTestFactory.java

+package de.ozgcloud.archive.common.xta;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+
+import de.ozgcloud.xta.client.model.XtaFile;
+import lombok.SneakyThrows;
+
+public class DocumentTestFactory {
+
+	public static final XtaFile FILE = XtaFileTestFactory.create();
+
+	public static Document create() {
+		return createFrom(FILE);
+	}
+
+	@SneakyThrows
+	public static Document createFrom(XtaFile file) {
+		return DocumentBuilderFactory.newDefaultInstance().newDocumentBuilder().parse(file.content().getDataSource().getInputStream());
+	}
+
+}

archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/XtaFileXmlUtilsTest.java → archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/XtaFileParserITCase.java

 package de.ozgcloud.archive.common.xta;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
-
-import java.util.function.Consumer;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
-import org.mockito.MockedStatic;
-import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import de.ozgcloud.common.test.ITCase;
 
-import de.ozgcloud.common.errorhandling.TechnicalException;
+@ITCase
+class XtaFileParserITCase {
 
-class XtaFileXmlUtilsTest {
+	@Autowired
+	private XtaFileParser parser;
 
 	@DisplayName("Is import confirmation")
 	@Nested
@@ -21,7 +21,7 @@ class XtaFileXmlUtilsTest {
 
 		@Test
 		void shouldReturnTrueOnMatchingTag() {
-			var isImportConfirmation = XtaFileXmlUtils.isType(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH),
+			var isImportConfirmation = parser.isType(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH),
 					XtaFileType.IMPORT_CONFIRMATION);
 
 			assertThat(isImportConfirmation).isTrue();
@@ -29,25 +29,10 @@ class XtaFileXmlUtilsTest {
 
 		@Test
 		void shouldReturnFalseOnNonMatchingTag() {
-			var isImportConfirmation = XtaFileXmlUtils.isType(XtaFileTestFactory.create(), XtaFileType.ABGABE);
+			var isImportConfirmation = parser.isType(XtaFileTestFactory.create(), XtaFileType.ABGABE);
 
 			assertThat(isImportConfirmation).isFalse();
 		}
-
-		@Test
-		void shouldReturnFalseOnException() {
-			mockStatic(XtaFileXmlUtils.class, mock -> {
-				mock.when(() -> XtaFileXmlUtils.parse(any())).thenThrow(new TechnicalException("DummyException"));
-
-				var isType = XtaFileXmlUtils.isType(XtaFileTestFactory.create(), XtaFileType.IMPORT_CONFIRMATION);
-				assertThat(isType).isFalse();
-			});
 	}
 
-		private <T> void mockStatic(Class<T> clazz, Consumer<MockedStatic<T>> mockConfigurer) {
-			try (var staticMock = Mockito.mockStatic(clazz, Mockito.CALLS_REAL_METHODS)) {
-				mockConfigurer.accept(staticMock);
-			}
-		}
-	}
 }
\ No newline at end of file

archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/XtaFileParserTest.java

+package de.ozgcloud.archive.common.xta;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.io.InputStream;
+
+import javax.xml.parsers.DocumentBuilder;
+
+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.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.springframework.core.io.ClassPathResource;
+import org.w3c.dom.Document;
+
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.ozgcloud.xta.client.model.XtaFile;
+import lombok.SneakyThrows;
+
+class XtaFileParserTest {
+
+	@Spy
+	@InjectMocks
+	private XtaFileParser parser;
+
+	@Mock
+	private DocumentBuilder documentBuilder;
+
+	@DisplayName("Is import confirmation")
+	@Nested
+	class TestIsType {
+
+		private final XtaFile file = XtaFileTestFactory.create();
+
+		@Test
+		@SneakyThrows
+		void shouldCallParse() {
+			isType();
+
+			verify(parser).parse(file);
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldReturnTrueOnMatchingTag() {
+			doReturn(AbgabeImportBestaetigen0402TestFactory.createAsDocument()).when(parser).parse(file);
+
+			var isImportConfirmation = isType();
+
+			assertThat(isImportConfirmation).isTrue();
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldReturnFalseOnNonMatchingTag() {
+			doReturn(DocumentTestFactory.create()).when(parser).parse(file);
+
+			var isImportConfirmation = isType();
+
+			assertThat(isImportConfirmation).isFalse();
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldReturnFalseOnException() {
+			doThrow(TechnicalException.class).when(parser).parse(any());
+
+			var isType = isType();
+
+			assertThat(isType).isFalse();
+		}
+
+		private boolean isType() {
+			return parser.isType(file, XtaFileType.IMPORT_CONFIRMATION);
+		}
+	}
+
+	@Nested
+	class TestParse {
+
+		private final XtaFile file = XtaFileTestFactory.create();
+		private final Document document = AbgabeImportBestaetigen0402TestFactory.createAsDocument();
+
+		@Captor
+		private ArgumentCaptor<InputStream> inputStreamCaptor;
+
+		@BeforeEach
+		@SneakyThrows
+		void mock() {
+			when(documentBuilder.parse(any(InputStream.class))).thenReturn(document);
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldCallDocumentBuilder() {
+			var expectedBytes = new ClassPathResource(XtaFileTestFactory.DUMMY_XML_FILE_PATH).getContentAsByteArray();
+
+			parse();
+
+			verify(documentBuilder).parse(inputStreamCaptor.capture());
+			assertThat(inputStreamCaptor.getValue().readAllBytes()).isEqualTo(expectedBytes);
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldReturnDocument() {
+			var result = parse();
+
+			assertThat(result).isEqualTo(document);
+		}
+
+		@SneakyThrows
+		private Document parse() {
+			return parser.parse(file);
+		}
+	}
+}
\ No newline at end of file

archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/XtaFileTestFactory.java

@@ -10,7 +10,7 @@ import lombok.SneakyThrows;
 
 public class XtaFileTestFactory {
 
-	private static final String DUMMY_XML_FILE_PATH = "xml-templates/dummy.xml";
+	public static final String DUMMY_XML_FILE_PATH = "xml-templates/dummy.xml";
 
 	public static XtaFile create() {
 		return create(DUMMY_XML_FILE_PATH);

archive-manager-server/src/test/java/de/ozgcloud/archive/quittung/QuittungServiceTest.java

@@ -12,6 +12,8 @@ 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.ValueSource;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.InjectMocks;
@@ -25,6 +27,9 @@ import de.ozgcloud.archive.common.command.CommandService;
 import de.ozgcloud.archive.common.command.CommandTestFactory;
 import de.ozgcloud.archive.common.xta.AbgabeImportBestaetigen0402TestFactory;
 import de.ozgcloud.archive.common.xta.XtaFileHelper;
+import de.ozgcloud.archive.common.xta.XtaFileParser;
+import de.ozgcloud.archive.common.xta.XtaFileTestFactory;
+import de.ozgcloud.archive.common.xta.XtaFileType;
 import de.ozgcloud.archive.common.xta.XtaImportConfirmationHandler;
 import de.ozgcloud.archive.common.xta.XtaImportConfirmationHandler.XtaAbgabeAdapter;
 import de.ozgcloud.archive.common.xta.XtaMessageTestFactory;
@@ -32,6 +37,7 @@ import de.ozgcloud.archive.common.xta.XtaService;
 import de.ozgcloud.archive.vorgang.VorgangWithEingangTestFactory;
 import de.ozgcloud.command.CommandExecutedEvent;
 import de.ozgcloud.command.CommandFailedEvent;
+import de.ozgcloud.xta.client.model.XtaFile;
 import de.ozgcloud.xta.client.model.XtaMessage;
 
 class QuittungServiceTest {
@@ -47,6 +53,8 @@ class QuittungServiceTest {
 	private ApplicationEventPublisher eventPublisher;
 	@Mock
 	private XtaFileHelper xtaFileHelper;
+	@Mock
+	private XtaFileParser xtaFileParser;
 
 	@Nested
 	class TestFetchQuittung {
@@ -132,6 +140,30 @@ class QuittungServiceTest {
 		}
 	}
 
+	@Nested
+	class TestIsImportConfirmation {
+
+		private XtaFile xtaFile = XtaFileTestFactory.create();
+
+		@Test
+		void shouldCallXtaFileParser() {
+			service.isImportConfirmation(xtaFile);
+
+			verify(xtaFileParser).isType(xtaFile, XtaFileType.IMPORT_CONFIRMATION);
+		}
+
+		@ParameterizedTest
+		@ValueSource(booleans = { true, false })
+		void shouldReturnIsType(boolean isImportConfirmation) {
+			when(xtaFileParser.isType(any(), any())).thenReturn(isImportConfirmation);
+
+			var returnValue = service.isImportConfirmation(xtaFile);
+
+			assertThat(returnValue).isEqualTo(isImportConfirmation);
+		}
+
+	}
+
 	@DisplayName("Handle abgabe")
 	@Nested
 	class TestHandleAbgabe {