Merge branch 'OZG-7038-EvaluationDMSQuittung' into 'main'

Ozg 7038 evaluation dms quittung

See merge request !3

archive-manager-server/src/test/java/de/ozgcloud/archive/common/command/CommandServiceTest.java

@@ -30,7 +30,9 @@ import static org.mockito.Mockito.*;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Stream;
 
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
@@ -43,8 +45,10 @@ import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
 import de.ozgcloud.apilib.common.command.grpc.OzgCloudCommandTestFactory;
 import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
 import de.ozgcloud.archive.vorgang.VorgangWithEingangTestFactory;
+import de.ozgcloud.command.CommandStatus;
 
 class CommandServiceTest {
+
 	@Spy
 	@InjectMocks
 	private CommandService service;
@@ -66,6 +70,31 @@ class CommandServiceTest {
 		}
 	}
 
+	@DisplayName("Find pending")
+	@Nested
+	class TestFindPending {
+
+		private final String order = LoremIpsum.getInstance().getWords(1);
+
+		@Test
+		void shouldCallRemoteService() {
+			service.findPending(VorgangWithEingangTestFactory.ID, order);
+
+			verify(remoteService).findCommands(VorgangWithEingangTestFactory.ID, Optional.of(CommandStatus.PENDING.name()),
+					Optional.of(order));
+		}
+
+		@Test
+		void shouldReturnValue() {
+			var command = ArchiveManagerCommand.builder().build();
+			when(remoteService.findCommands(any(), any(), any())).thenReturn(Stream.of(command));
+
+			var commands = service.findPending(VorgangWithEingangTestFactory.ID, order).toList();
+
+			assertThat(commands).containsExactly(command);
+		}
+	}
+
 	@Nested
 	class TestHasPendingCommandsExceptArchive {
 

archive-manager-server/src/test/java/de/ozgcloud/archive/common/command/CommandTestFactory.java

@@ -25,33 +25,55 @@ package de.ozgcloud.archive.common.command;
 
 import java.time.ZonedDateTime;
 import java.util.Map;
+import java.util.UUID;
 
 import com.thedeanda.lorem.LoremIpsum;
 
-import de.ozgcloud.archive.common.command.ArchiveManagerCommand.ArchiveManagerCommandBuilder;
 import de.ozgcloud.archive.common.user.UserProfileTestFactory;
+import de.ozgcloud.command.CommandStatus;
 
 public class CommandTestFactory {
 
-	public static final ZonedDateTime FINISHED_AT = ZonedDateTime.now();
+	public static final String ID = UUID.randomUUID().toString();
+	public static final String VORGANG_ID = UUID.randomUUID().toString();;
+
 	public static final String CREATED_BY_NAME = UserProfileTestFactory.FULLNAME;
 	public static final String ORDER = LoremIpsum.getInstance().getWords(1);
+	public static final CommandStatus STATUS = CommandStatus.FINISHED;
+
+	public static final String BODY_FIELD_NAME = LoremIpsum.getInstance().getWords(1);
+	public static final String BODY_FIELD_VALUE = LoremIpsum.getInstance().getWords(1);
+	public static final Map<String, Object> BODY = Map.of(BODY_FIELD_NAME, BODY_FIELD_VALUE);
+
+	public static final String RELATION_ID = UUID.randomUUID().toString();
+	public static final long RELATION_VERSION = 42;
+
+	public static final String CREATED_AT_STR = "2023-08-18T13:54:10Z";
+	public static final ZonedDateTime CREATED_AT = ZonedDateTime.parse(CREATED_AT_STR);
+	public static final String FINISHED_AT_STR = "2023-08-18T13:55:10Z";
+	public static final ZonedDateTime FINISHED_AT = ZonedDateTime.parse(FINISHED_AT_STR);
 
-	public static final String PROPERTY_1 = LoremIpsum.getInstance().getWords(1);
-	public static final String PROPERTY_2 = LoremIpsum.getInstance().getWords(1);
-	public static final String VALUE_1 = LoremIpsum.getInstance().getWords(1);
-	public static final String VALUE_2 = LoremIpsum.getInstance().getWords(1);
-	public static final Map<String, Object> BODY = Map.of(PROPERTY_1, VALUE_1, PROPERTY_2, VALUE_2);
+	public static final String CREATED_RESOURCE = UUID.randomUUID().toString();
+	public static final String CREATED_BY = UUID.randomUUID().toString();
+	public static final String ERROR_MESSAGE = "An error occurred";
 
 	public static ArchiveManagerCommand create() {
-		return createBuilder()
-				.build();
+		return createBuilder().build();
 	}
 
-	public static ArchiveManagerCommandBuilder createBuilder() {
-		return ArchiveManagerCommand.builder().body(BODY)
+	public static ArchiveManagerCommand.ArchiveManagerCommandBuilder createBuilder() {
+		return ArchiveManagerCommand.builder()
+				.id(ID)
+				.vorgangId(VORGANG_ID)
+				.relationId(RELATION_ID)
+				.order(ORDER)
+				.status(STATUS)
+				.createdAt(CREATED_AT)
 				.finishedAt(FINISHED_AT)
+				.bodyObject(BODY)
+				.createdResource(CREATED_RESOURCE)
+				.createdBy(CREATED_BY)
 				.createdByName(CREATED_BY_NAME)
-				.order(ORDER);
+				.errorMessage(ERROR_MESSAGE);
 	}
 }
\ No newline at end of file

archive-manager-server/src/test/java/de/ozgcloud/archive/common/command/GrpcCommandTestFactory.java

+package de.ozgcloud.archive.common.command;
+
+import de.ozgcloud.vorgang.common.GrpcObject;
+import de.ozgcloud.vorgang.common.GrpcProperty;
+import de.ozgcloud.vorgang.grpc.command.GrpcCommand;
+
+public class GrpcCommandTestFactory {
+
+	public static final GrpcObject BODY_OBJECT = GrpcObject.newBuilder()
+			.addProperty(GrpcProperty.newBuilder()
+					.setName(CommandTestFactory.BODY_FIELD_NAME).addValue(CommandTestFactory.BODY_FIELD_VALUE))
+			.build();
+
+	public static GrpcCommand create() {
+		return createBuilder().build();
+	}
+
+	public static GrpcCommand.Builder createBuilder() {
+		return GrpcCommand.newBuilder()
+				.setId(CommandTestFactory.ID.toString())
+				.setVorgangId(CommandTestFactory.VORGANG_ID)
+				.setCreatedAt(CommandTestFactory.CREATED_AT_STR)
+				.setFinishedAt(CommandTestFactory.FINISHED_AT_STR)
+				.setCreatedBy(CommandTestFactory.CREATED_BY)
+				.setCreatedByName(CommandTestFactory.CREATED_BY_NAME)
+				.setStatus(CommandTestFactory.STATUS.toString())
+				.setErrorMessage(CommandTestFactory.ERROR_MESSAGE)
+				.setRelationId(CommandTestFactory.RELATION_ID)
+				.setBodyObj(BODY_OBJECT)
+				.setOrderString(CommandTestFactory.ORDER)
+				.setCreatedResource(CommandTestFactory.CREATED_RESOURCE);
+	}
+}

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

+package de.ozgcloud.archive.common.xta;
+
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Unmarshaller;
+
+import org.w3c.dom.Document;
+
+import de.xoev.xdomea.AbgabeImportBestaetigen0402;
+import lombok.SneakyThrows;
+
+public class AbgabeImportBestaetigen0402TestFactory {
+
+	public static final String VORGANG_ID = "DummyVorgangId";
+	public static final boolean ERFOLGREICH = false;
+	public static final String FEHLERMELDUNG = "Grund, warum der Import nicht funktioniert hat.";
+
+	public static final String FILE_PATH = "xml-templates/21b2f942-c454-44e6-a706-c4f6ef2d584a_Abgabe.ImportBestaetigen.0402.xml";
+
+	@SneakyThrows
+	public static AbgabeImportBestaetigen0402 create() {
+		return (AbgabeImportBestaetigen0402) getUnmarshaller()
+				.unmarshal(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH).content().getInputStream());
+	}
+
+	private static Unmarshaller getUnmarshaller() throws JAXBException {
+		return JAXBContext.newInstance(AbgabeImportBestaetigen0402.class).createUnmarshaller();
+	}
+
+	@SneakyThrows
+	public static Document createAsDocument() {
+		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/XtaFileHelperTest.java

+package de.ozgcloud.archive.common.xta;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+
+class XtaFileHelperTest {
+
+	@InjectMocks
+	private XtaFileHelper service;
+
+	@DisplayName("Init import confirmation handler")
+	@Nested
+	class TestInitImportConfirmationHandler {
+
+		@Test
+		void shouldReturnInstanceOfHandler() {
+			var handler = service.initImportConfirmationHandler(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH));
+
+			assertThat(handler).isNotNull().isInstanceOf(XtaImportConfirmationHandler.class);
+		}
+	}
+}
\ No newline at end of file

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 org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import de.ozgcloud.common.test.ITCase;
+
+@ITCase
+class XtaFileParserITCase {
+
+	@Autowired
+	private XtaFileParser parser;
+
+	@DisplayName("Is import confirmation")
+	@Nested
+	class TestIsType {
+
+		@Test
+		void shouldReturnTrueOnMatchingTag() {
+			var isImportConfirmation = parser.isType(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH),
+					XtaFileType.IMPORT_CONFIRMATION);
+
+			assertThat(isImportConfirmation).isTrue();
+		}
+
+		@Test
+		void shouldReturnFalseOnNonMatchingTag() {
+			var isImportConfirmation = parser.isType(XtaFileTestFactory.create(), XtaFileType.ABGABE);
+
+			assertThat(isImportConfirmation).isFalse();
+		}
+	}
+
+}
\ 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/XtaFileReaderTest.java

+package de.ozgcloud.archive.common.xta;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.Unmarshaller;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.ozgcloud.common.test.ReflectionTestUtils;
+import de.ozgcloud.xta.client.model.XtaFile;
+import de.xoev.xdomea.AbgabeImportBestaetigen0402;
+import lombok.SneakyThrows;
+
+class XtaFileReaderTest {
+
+	@Nested
+	class TestCreateAbgabeImportBestaetigen0402Reader {
+
+		@Test
+		void shouldCreateReader() {
+			var reader = XtaFileReader.createAbgabeImportBestaetigen0402Reader();
+
+			assertThat(reader).isExactlyInstanceOf(XtaFileReader.class);
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldSetUnmarshaller() {
+			var reader = XtaFileReader.createAbgabeImportBestaetigen0402Reader();
+
+			assertThat(ReflectionTestUtils.getField(reader, "unmarshaller", Unmarshaller.class)).usingRecursiveComparison()
+					.isEqualTo(JAXBContext.newInstance(AbgabeImportBestaetigen0402.class).createUnmarshaller());
+		}
+	}
+
+	@Nested
+	class TestRead {
+
+		@Test
+		@SneakyThrows
+		void shouldReadContent() {
+			var reader = XtaFileReader.createAbgabeImportBestaetigen0402Reader();
+
+			var abgabe = reader.read(XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH));
+
+			assertThat(abgabe).usingRecursiveComparison().isEqualTo(AbgabeImportBestaetigen0402TestFactory.create());
+		}
+
+		@Test
+		@SneakyThrows
+		void shouldThrowTechnicalException() {
+			var reader = XtaFileReader.createAbgabeImportBestaetigen0402Reader();
+			XtaFile unknownFile = XtaFileTestFactory.create(XtaFileTestFactory.DUMMY_XML_FILE_PATH);
+
+			assertThrows(TechnicalException.class, () -> reader.read(unknownFile));
+		}
+	}
+}

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

+package de.ozgcloud.archive.common.xta;
+
+import jakarta.activation.DataHandler;
+import jakarta.activation.FileDataSource;
+
+import org.springframework.core.io.ClassPathResource;
+
+import de.ozgcloud.xta.client.model.XtaFile;
+import lombok.SneakyThrows;
+
+public class XtaFileTestFactory {
+
+	public static final String DUMMY_XML_FILE_PATH = "xml-templates/dummy.xml";
+
+	public static XtaFile create() {
+		return create(DUMMY_XML_FILE_PATH);
+	}
+
+	public static XtaFile create(String filePath) {
+		return createBuilder(filePath).build();
+	}
+
+	public static XtaFile.XtaFileBuilder createBuilder() {
+		return createBuilder(DUMMY_XML_FILE_PATH);
+	}
+
+	public static XtaFile.XtaFileBuilder createBuilder(String filePath) {
+		return XtaFile.builder()
+				.content(createDataHandler(filePath));
+	}
+
+	@SneakyThrows
+	private static DataHandler createDataHandler(String filePath) {
+		var file = new ClassPathResource(filePath).getFile();
+		return new DataHandler(new FileDataSource(file));
+	}
+}
\ No newline at end of file

archive-manager-server/src/test/java/de/ozgcloud/archive/common/xta/XtaImportConfirmationHandlerTest.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 org.junit.jupiter.api.AfterEach;
+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.Mock;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.archive.common.xta.XtaImportConfirmationHandler.XtaAbgabeAdapter;
+import de.ozgcloud.common.test.ReflectionTestUtils;
+import de.ozgcloud.xta.client.model.XtaFile;
+import de.xoev.xdomea.AbgabeImportBestaetigen0402;
+
+class XtaImportConfirmationHandlerTest {
+
+	@DisplayName("Xta import confirmation handler")
+	@Nested
+	class TestXtaImportConfirmationHandler {
+
+		private final AbgabeImportBestaetigen0402 importConfirmation = AbgabeImportBestaetigen0402TestFactory.create();
+		private final XtaFile file = XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH);
+
+		@Mock
+		private XtaFileReader<AbgabeImportBestaetigen0402> reader;
+
+		@Nested
+		class TestCreateFrom {
+
+			@SuppressWarnings("rawtypes")
+			private MockedStatic<XtaFileReader> fileReaderStaticMock;
+
+			@BeforeEach
+			void initMock() {
+				fileReaderStaticMock = mockStatic(XtaFileReader.class);
+				fileReaderStaticMock.when(XtaFileReader::createAbgabeImportBestaetigen0402Reader).thenReturn(reader);
+			}
+
+			@AfterEach
+			void closeMock() {
+				fileReaderStaticMock.close();
+			}
+
+			@Test
+			void shouldReadFileContent() {
+				XtaImportConfirmationHandler.createFrom(file);
+
+				verify(reader).read(file);
+			}
+
+			@Test
+			void shouldSetImportConfirmation() {
+				when(reader.read(any())).thenReturn(importConfirmation);
+
+				var confiHandler = XtaImportConfirmationHandler.createFrom(file);
+
+				assertThat(ReflectionTestUtils.getField(confiHandler, "importConfirmation", AbgabeImportBestaetigen0402.class))
+						.usingRecursiveComparison().isEqualTo(importConfirmation);
+
+			}
+
+		}
+
+		@Nested
+		class TestGetAbgaben {
+			private final XtaFile file = XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH);
+
+			@Test
+			void shouldReturnAbgabenAsHandler() {
+				var handler = XtaImportConfirmationHandler.createFrom(file);
+
+				assertThat(handler.getAbgaben()).hasSize(1);
+				assertThat(handler.getAbgaben().findFirst()).isPresent().get().isInstanceOf(XtaAbgabeAdapter.class);
+			}
+		}
+	}
+
+	@DisplayName("Xta abgabe handler")
+	@Nested
+	class TestXtaAbgabeAdapter {
+
+		private final XtaFile file = XtaFileTestFactory.create(AbgabeImportBestaetigen0402TestFactory.FILE_PATH);
+
+		@Test
+		void shouldReturnVorgangId() {
+			var vorgangId = initAbgabeHandler().getVorgangId();
+
+			assertThat(vorgangId).isEqualTo(AbgabeImportBestaetigen0402TestFactory.VORGANG_ID);
+		}
+
+		@Test
+		void shouldReturnIsSucessful() {
+			var isSuccessful = initAbgabeHandler().isSuccessful();
+
+			assertThat(isSuccessful).isEqualTo(AbgabeImportBestaetigen0402TestFactory.ERFOLGREICH);
+		}
+
+		@Test
+		void shouldReturnErrorMessage() {
+			var errorMessage = initAbgabeHandler().getErrorMessage();
+
+			assertThat(errorMessage).isEqualTo(AbgabeImportBestaetigen0402TestFactory.FEHLERMELDUNG);
+		}
+
+		private XtaAbgabeAdapter initAbgabeHandler() {
+			return initImportConfirmationHandler().getAbgaben().findFirst().get();
+		}
+
+		private XtaImportConfirmationHandler initImportConfirmationHandler() {
+			return XtaImportConfirmationHandler.createFrom(file);
+		}
+	}
+}
\ No newline at end of file

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

+package de.ozgcloud.archive.common.xta;
+
+import de.ozgcloud.xta.client.model.XtaFile;
+import de.ozgcloud.xta.client.model.XtaMessage;
+
+public class XtaMessageTestFactory {
+
+	public static final XtaFile MESSAGE_FILE = XtaFileTestFactory.create();
+
+	public static XtaMessage create() {
+		return createBuilder().build();
+	}
+
+	public static XtaMessage.XtaMessageBuilder createBuilder() {
+		return XtaMessage.builder()
+				.messageFile(MESSAGE_FILE);
+	}
+}
\ No newline at end of file

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

@@ -6,16 +6,20 @@ import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Optional;
+import java.util.function.Consumer;
 
 import org.junit.jupiter.api.AfterEach;
 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.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Spy;
+import org.springframework.context.ApplicationEventPublisher;
 
+import de.ozgcloud.archive.common.command.CommandService;
 import de.ozgcloud.archive.vorgang.XdomeaXtaFileTestFactory;
 import de.ozgcloud.common.errorhandling.TechnicalException;
 import de.ozgcloud.xta.client.XtaClient;
@@ -148,6 +152,15 @@ class XtaServiceTest {
 
 		private XtaService xtaService;
 
+		@Mock
+		private XtaFileHelper xtaFileHelper;
+
+		@Mock
+		private CommandService commandService;
+
+		@Mock
+		private ApplicationEventPublisher eventPublisher;
+
 		@Nested
 		class TestOnConfiguredXtaClient {
 
@@ -183,4 +196,45 @@ class XtaServiceTest {
 			return xtaService.getXtaClient();
 		}
 	}
+
+	@DisplayName("Fetch messages")
+	@Nested
+	class TestFetchMessages {
+
+		@Mock
+		private Consumer<XtaMessage> messageConsumer;
+
+		@BeforeEach
+		void mock() {
+			doReturn(xtaClient).when(service).getXtaClient();
+		}
+
+		@Test
+		void shouldCallGetXtaClient() {
+			fetchMessages();
+
+			verify(service).getXtaClient();
+		}
+
+		@SneakyThrows
+		@Test
+		void shouldCallClient() {
+			fetchMessages();
+
+			verify(xtaClient).fetchMessages(messageConsumer);
+		}
+
+		@SneakyThrows
+		@Test
+		void shouldThrowException() {
+			when(xtaClient.fetchMessages(any())).thenThrow(new XtaClientException("error-message"));
+
+			assertThatThrownBy(this::fetchMessages).isInstanceOf(TechnicalException.class);
+		}
+
+		private void fetchMessages() {
+			service.fetchMessages(messageConsumer);
+		}
+	}
+
 }

archive-manager-server/src/test/java/de/ozgcloud/archive/export/ExportGrpcServiceTest.java

@@ -176,7 +176,8 @@ class ExportGrpcServiceTest {
 		@Mock
 		private OutputStream outputStream;
 
-		private MockedConstruction<GrpcBinaryFileServerDownloader> downloaderMockedConstruction; // NOSONAR
+		@SuppressWarnings("rawtypes")
+		private MockedConstruction<GrpcBinaryFileServerDownloader> downloaderMockedConstruction;
 		private GrpcBinaryFileServerDownloader<GrpcExportVorgangResponse> downloader;
 		private StreamObserver<GrpcExportVorgangResponse> setResponseObserver;
 		private TaskExecutor setTaskExecutor;

archive-manager-server/src/test/java/de/ozgcloud/archive/historie/AktenzeichenChangeHistoryBuilderTest.java

@@ -185,14 +185,14 @@ public class AktenzeichenChangeHistoryBuilderTest {
 
 		@BeforeEach
 		void init() {
-			when(builder.getValueFromCommandBody(BODY_PROPERTY_AKTENZEICHEN, previousCommand)).thenReturn(AKTENZEICHEN);
+			when(builder.getValueFromCommandBodyObject(BODY_PROPERTY_AKTENZEICHEN, previousCommand)).thenReturn(AKTENZEICHEN);
 		}
 
 		@Test
 		void shouldGetValueFromCommandBody() {
 			builder.getAktenzeichen(previousCommand);
 
-			verify(builder).getValueFromCommandBody(BODY_PROPERTY_AKTENZEICHEN, previousCommand);
+			verify(builder).getValueFromCommandBodyObject(BODY_PROPERTY_AKTENZEICHEN, previousCommand);
 		}
 
 		@Test

archive-manager-server/src/test/java/de/ozgcloud/archive/historie/AssignedUserChangeHistoryBuilderTest.java

@@ -217,7 +217,7 @@ public class AssignedUserChangeHistoryBuilderTest {
 
 		@BeforeEach
 		void init() {
-			doReturn(UserProfileTestFactory.USER_ID).when(builder).getValueFromCommandBody(any(), any());
+			doReturn(UserProfileTestFactory.USER_ID).when(builder).getValueFromCommandBodyObject(any(), any());
 			doReturn(Optional.of(UserProfileTestFactory.create())).when(userProfileCache).getUserProfile(any());
 		}
 
@@ -225,7 +225,7 @@ public class AssignedUserChangeHistoryBuilderTest {
 		void shouldGetUserIdFromCommand() {
 			callBuilder();
 
-			verify(builder).getValueFromCommandBody(BODY_PROPERTY_ASSIGNED_USER, previousCommand);
+			verify(builder).getValueFromCommandBodyObject(BODY_PROPERTY_ASSIGNED_USER, previousCommand);
 		}
 
 		@Test

archive-manager-server/src/test/java/de/ozgcloud/archive/historie/ChangeHistoryBuilderTest.java

@@ -252,19 +252,19 @@ public class ChangeHistoryBuilderTest {
 
 		@ParameterizedTest
 		@NullAndEmptySource
-		void shouldReturnEmptyIfBodyIsNullOrEmpty(Map<String, ?> body) {
-			var command = previousCommand.toBuilder().body(body).build();
+		void shouldReturnEmptyIfBodyIsNullOrEmpty(Map<String, Object> body) {
+			var command = previousCommand.toBuilder().bodyObject(body).build();
 
-			var value = builder.getValueFromCommandBody(PROPERTY_NAME, command);
+			var value = builder.getValueFromCommandBodyObject(PROPERTY_NAME, command);
 
 			assertThat(value).isEmpty();
 		}
 
 		@Test
 		void shouldReturnEmptyIfPropertyIsNotPresentInBody() {
-			var command = previousCommand.toBuilder().body(Map.of("a", "b")).build();
+			var command = previousCommand.toBuilder().bodyObject(Map.of("a", "b")).build();
 
-			var value = builder.getValueFromCommandBody(PROPERTY_NAME, command);
+			var value = builder.getValueFromCommandBodyObject(PROPERTY_NAME, command);
 
 			assertThat(value).isEmpty();
 		}
@@ -272,9 +272,9 @@ public class ChangeHistoryBuilderTest {
 		@Test
 		void shouldReturnValueFromBody() {
 			var expectedValue = LoremIpsum.getInstance().getWords(2);
-			var command = previousCommand.toBuilder().body(Map.of(PROPERTY_NAME, expectedValue)).build();
+			var command = previousCommand.toBuilder().bodyObject(Map.of(PROPERTY_NAME, expectedValue)).build();
 
-			var value = builder.getValueFromCommandBody(PROPERTY_NAME, command);
+			var value = builder.getValueFromCommandBodyObject(PROPERTY_NAME, command);
 
 			assertThat(value).isEqualTo(expectedValue);
 		}

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

+package de.ozgcloud.archive.quittung;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+class QuittungSchedulerTest {
+
+	@Spy
+	@InjectMocks
+	private QuittungScheduler scheduler;
+	@Mock
+	private QuittungService service;
+
+	@Nested
+	class TestOnStartup {
+
+		@Test
+		void shouldCallRun() {
+			scheduler.onStartup();
+
+			verify(scheduler).run();
+		}
+	}
+
+	@Nested
+	class TestRun {
+
+		@Test
+		void shouldCallService() {
+			scheduler.run();
+
+			verify(service).fetchQuittung();
+		}
+	}
+}
\ No newline at end of file

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

+package de.ozgcloud.archive.quittung;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+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;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.springframework.context.ApplicationEventPublisher;
+
+import de.ozgcloud.archive.common.command.ArchiveManagerCommand;
+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;
+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 {
+
+	@Spy
+	@InjectMocks
+	private QuittungService service;
+	@Mock
+	private XtaService xtaService;
+	@Mock
+	private CommandService commandService;
+	@Mock
+	private ApplicationEventPublisher eventPublisher;
+	@Mock
+	private XtaFileHelper xtaFileHelper;
+	@Mock
+	private XtaFileParser xtaFileParser;
+
+	@Nested
+	class TestFetchQuittung {
+
+		@Captor
+		private ArgumentCaptor<Consumer<XtaMessage>> consumerCaptor;
+
+		private final XtaMessage message = XtaMessageTestFactory.create();
+
+		@Test
+		void shouldCallXtaService() {
+			service.fetchQuittung();
+
+			verify(xtaService).fetchMessages(any());
+		}
+
+		@Test
+		void shouldPassQuittungConsumerToXtaService() {
+			service.fetchQuittung();
+
+			verify(xtaService).fetchMessages(consumerCaptor.capture());
+			consumerCaptor.getValue().accept(message);
+			verify(service).consumeQuittung(message);
+		}
+	}
+
+	@DisplayName("Consume Quittung")
+	@Nested
+	class TestConsumeQuittung {
+
+		@Mock
+		private XtaImportConfirmationHandler xtaFileContentHandler;
+
+		private final XtaMessage xtaMessage = XtaMessageTestFactory.create();
+
+		@Test
+		void shouldCallIsImportConfirmation() {
+			service.consumeQuittung(xtaMessage);
+
+			verify(service).isImportConfirmation(XtaMessageTestFactory.MESSAGE_FILE);
+		}
+
+		@DisplayName("on import confirmation")
+		@Nested
+		class TestOnImportConfirmation {
+
+			@Mock
+			private XtaAbgabeAdapter abgabeHandler;
+
+			@BeforeEach
+			void mock() {
+				doReturn(true).when(service).isImportConfirmation(any());
+				when(xtaFileHelper.initImportConfirmationHandler(any())).thenReturn(xtaFileContentHandler);
+				when(xtaFileContentHandler.getAbgaben()).thenReturn(Stream.of(abgabeHandler, abgabeHandler));
+				doNothing().when(service).handleAbgabe(any());
+			}
+
+			@Test
+			void shouldInitContentHandler() {
+				service.consumeQuittung(xtaMessage);
+
+				verify(xtaFileHelper).initImportConfirmationHandler(XtaMessageTestFactory.MESSAGE_FILE);
+			}
+
+			@DisplayName("should handle import confirmation if type from document is matching")
+			@Test
+			void shouldCallHandleAbgabe() {
+				service.consumeQuittung(xtaMessage);
+
+				verify(service, times(2)).handleAbgabe(abgabeHandler);
+			}
+		}
+
+		@DisplayName("should not handle message if its not an import confirmation")
+		@Test
+		void shouldNotProceed() {
+			doReturn(false).when(service).isImportConfirmation(any());
+
+			service.consumeQuittung(xtaMessage);
+
+			verify(service, never()).handleAbgabe(any());
+			verify(xtaFileHelper, never()).initImportConfirmationHandler(any());
+		}
+	}
+
+	@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 {
+
+		@Mock
+		private XtaAbgabeAdapter abgabeHandler;
+
+		@BeforeEach
+		void mock() {
+			when(abgabeHandler.getVorgangId()).thenReturn(VorgangWithEingangTestFactory.ID);
+			when(commandService.findPending(any(), any())).thenReturn(Stream.empty());
+		}
+
+		@Test
+		void shouldGetVorgangId() {
+			handleImportConfirmation();
+
+			verify(abgabeHandler).getVorgangId();
+		}
+
+		@Test
+		void shouldCallCommandService() {
+			handleImportConfirmation();
+
+			verify(commandService).findPending(VorgangWithEingangTestFactory.ID, QuittungService.ARCHIVE_VORGANG_ORDER);
+		}
+
+		@DisplayName("on existing pending commands")
+		@Nested
+		class TestOnExistingPendingCommands {
+
+			private final ArchiveManagerCommand command = CommandTestFactory.create();
+			private final List<ArchiveManagerCommand> commands = List.of(command);
+
+			@BeforeEach
+			void mock() {
+				when(commandService.findPending(any(), any())).thenReturn(commands.stream());
+				doNothing().when(service).evaluateAbgabe(any(), any());
+			}
+
+			@Test
+			void shouldCallEvaluateConfirmation() {
+				handleImportConfirmation();
+
+				verify(service).evaluateAbgabe(abgabeHandler, commands);
+			}
+		}
+
+		@Test
+		void shouldNotCallEvaluateImportConfirmationOnEmptyList() {
+			handleImportConfirmation();
+
+			verify(service, never()).evaluateAbgabe(any(), any());
+		}
+
+		private void handleImportConfirmation() {
+			service.handleAbgabe(abgabeHandler);
+		}
+	}
+
+	@DisplayName("Evaluate abgabe")
+	@Nested
+	class TestEvaluateConfirmation {
+
+		@Mock
+		private XtaAbgabeAdapter abgabeHandler;
+
+		private final ArchiveManagerCommand command = CommandTestFactory.create();
+		private final List<ArchiveManagerCommand> commands = List.of(command, command);
+
+		@Test
+		void shouldCallIsSuccessfullyDone() {
+			service.evaluateAbgabe(abgabeHandler, commands);
+
+			verify(abgabeHandler).isSuccessful();
+		}
+
+		@Test
+		void shouldCallPublishCommendExcecutedEvent() {
+			when(abgabeHandler.isSuccessful()).thenReturn(true);
+
+			service.evaluateAbgabe(abgabeHandler, commands);
+
+			verify(service, times(2)).publishCommandExecutedEvent(command);
+		}
+
+		@Test
+		void shouldCallPublishCommandFailedEvent() {
+			when(abgabeHandler.isSuccessful()).thenReturn(false);
+
+			service.evaluateAbgabe(abgabeHandler, commands);
+
+			verify(service, times(2)).publishCommandFailedEvent(abgabeHandler, command);
+		}
+
+		@DisplayName("on successfully done import confirmation")
+		@Nested
+		class TestPublishCommandExcutedEvent {
+
+			@Captor
+			private ArgumentCaptor<CommandExecutedEvent> commandExecutedEventCaptor;
+
+			@DisplayName("should publish command executed event")
+			@Test
+			void shouldPublishCommandExecutedEvent() {
+				service.publishCommandExecutedEvent(command);
+
+				verify(eventPublisher).publishEvent(commandExecutedEventCaptor.capture());
+				assertThat(commandExecutedEventCaptor.getValue().getCommand()).isEqualTo(command);
+			}
+		}
+
+		@DisplayName("on failed import confirmation")
+		@Nested
+		class TestPublishCommandFailedEvent {
+
+			@Captor
+			private ArgumentCaptor<CommandFailedEvent> commandFailedEventCaptor;
+
+			private final ArchiveManagerCommand command = CommandTestFactory.create();
+
+			@DisplayName("should publish command failed event")
+			@Test
+			void shouldPublishCommandFailedEvent() {
+				when(abgabeHandler.getErrorMessage()).thenReturn(AbgabeImportBestaetigen0402TestFactory.FEHLERMELDUNG);
+
+				service.publishCommandFailedEvent(abgabeHandler, command);
+
+				verify(eventPublisher).publishEvent(commandFailedEventCaptor.capture());
+				assertThat(commandFailedEventCaptor.getValue().getSource()).isEqualTo(CommandTestFactory.ID);
+				assertThat(commandFailedEventCaptor.getValue().getErrorMessage()).isEqualTo(AbgabeImportBestaetigen0402TestFactory.FEHLERMELDUNG);
+			}
+		}
+	}
+}

archive-manager-server/src/test/resources/xml-templates/21b2f942-c454-44e6-a706-c4f6ef2d584a_Abgabe.ImportBestaetigen.0402.xml

+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<xdomea:Abgabe.ImportBestaetigen.0402 xmlns:xoev-code="http://xoev.de/schemata/code/1_0" xmlns:gml="http://www.opengis.net/gml/3.2" xmlns:xoev-lc="http://xoev.de/latinchars/1_1/datatypes" xmlns:dinspec91379="urn:xoev-de:kosit:xoev:datentyp:din-spec-91379_2019-03" xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0" xmlns:ns3="urn:ozgcloud-de:xdomea:schema:1.0.0">
+    <xdomea:Kopf>
+        <xdomea:ProzessID>662912249c67ff057850e259</xdomea:ProzessID>
+        <xdomea:Nachrichtentyp listURI="urn:xoev-de:xdomea:codeliste:nachrichtentyp" listVersionID="2.0">
+            <code>0402</code>
+        </xdomea:Nachrichtentyp>
+        <xdomea:Erstellungszeitpunkt>2024-04-24T14:21:30.331Z</xdomea:Erstellungszeitpunkt>
+        <xdomea:Absender>
+            <xdomea:Behoerdenkennung>
+                <xdomea:Behoerdenschluessel listURI="urn:de:bund:destatis:bevoelkerungsstatistik:schluessel:rs" listVersionID="2023-11-30"/>
+            </xdomea:Behoerdenkennung>
+            <xdomea:Organisationseinheit>
+                <xdomea:Name>9030229</xdomea:Name>
+            </xdomea:Organisationseinheit>
+        </xdomea:Absender>
+        <xdomea:Empfaenger>
+            <xdomea:Behoerdenkennung>
+                <xdomea:Behoerdenschluessel listURI="urn:de:bund:destatis:bevoelkerungsstatistik:schluessel:rs" listVersionID="2023-11-30"/>
+            </xdomea:Behoerdenkennung>
+        </xdomea:Empfaenger>
+		
+        <xdomea:SendendesSystem>
+            <xdomea:Produktname>DMS-Name</xdomea:Produktname>
+        </xdomea:SendendesSystem>
+    </xdomea:Kopf>
+    <xdomea:AbgegebenesObjekt>
+        <xdomea:IDSGO>DummyVorgangId</xdomea:IDSGO>
+        <xdomea:Erfolgreich>false</xdomea:Erfolgreich>
+        <xdomea:Fehlermeldung>Grund, warum der Import nicht funktioniert hat.</xdomea:Fehlermeldung>
+    </xdomea:AbgegebenesObjekt>
+</xdomea:Abgabe.ImportBestaetigen.0402>
\ No newline at end of file