Merge branch 'master' into OZG-4713-xdomea-aenderung-historie

# Conflicts:
#	alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java
#	alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java
#	alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java
#	alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java
#	alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java

alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java

+package de.ozgcloud.alfa.kommentar;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.apache.commons.io.FilenameUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.DateiformatCodeTypeTestFactory;
+import de.ozgcloud.alfa.common.FormatTypeTestFactory;
+import de.ozgcloud.alfa.common.PrimaerdokumentTypeBuilder;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.VersionTypeTestFactory;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.FormatType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+
+class DokumentTypeBuilderTest {
+
+	@Spy
+	private DokumentTypeBuilder builder = DokumentTypeBuilder.builder();
+
+	@Nested
+	class TestBuild {
+
+		private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+		private final OzgFile ozgFile = OzgFileTestFactory.create();
+		private final AnlageDokumentType anlageDokumentType = AnlageDokumentTypeTestFactory.create();
+
+		@BeforeEach
+		void setUp() {
+			doReturn(identifikationObjektType).when(builder).createKommentarIdentifikation();
+		}
+
+		@Test
+		void shouldCreateIdentifikation() {
+			builder.build();
+
+			verify(builder).createKommentarIdentifikation();
+		}
+
+		@Nested
+		class WithoutKommentareAttachments {
+
+			@Test
+			void shouldHaveIdentifikation() {
+				var dokumentType = builder.build();
+
+				assertThat(dokumentType.getIdentifikation()).isEqualTo(identifikationObjektType);
+			}
+
+			@Test
+			void shouldHaveTypNotiz() {
+				var dokumentType = builder.build();
+
+				assertThat(dokumentType.getTyp()).isEqualTo(DokumentTypeBuilder.TYP);
+			}
+		}
+
+		@Nested
+		class WithKommentareAttachments {
+
+			@BeforeEach
+			void setUp() {
+				doReturn(anlageDokumentType).when(builder).createAnlage(ozgFile);
+			}
+
+			@Test
+			void shouldCreateAnlagenForKommentarAttachments() {
+				builder.withKommentarAttachments(List.of(ozgFile)).build();
+
+				verify(builder).createAnlage(ozgFile);
+			}
+
+			@Test
+			void shouldHaveAnlagen() {
+				var dokumentType = builder.withKommentarAttachments(List.of(ozgFile)).build();
+
+				assertThat(dokumentType.getAnlage()).contains(anlageDokumentType);
+			}
+		}
+	}
+
+	@Nested
+	class TestCreateKommentarIdentifikation {
+
+		private MockedStatic<UUIDConverter> uuidConverterMockedStatic;
+
+		@BeforeEach
+		void setUp() {
+			uuidConverterMockedStatic = mockStatic(UUIDConverter.class);
+			uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(KommentarTestFactory.ID))
+					.thenReturn(IdentifikationObjektTypeTestFactory.ID);
+		}
+
+		@AfterEach
+		void tearDown() {
+			uuidConverterMockedStatic.close();
+		}
+
+		@Test
+		void shouldConvertKommentarId() {
+			builder.withKommentar(KommentarTestFactory.create()).createKommentarIdentifikation();
+
+			uuidConverterMockedStatic.verify(() -> UUIDConverter.fromObjectId(KommentarTestFactory.ID));
+		}
+
+		@Test
+		void shouldHaveId() {
+			var identifikation = builder.withKommentar(KommentarTestFactory.create()).createKommentarIdentifikation();
+
+			assertThat(identifikation.getID()).isEqualTo(IdentifikationObjektTypeTestFactory.ID);
+		}
+	}
+
+	@Nested
+	class TestCreateKommentarAttachmentIdentifikation {
+
+		private MockedStatic<UUIDConverter> uuidConverterMockedStatic;
+
+		@BeforeEach
+		void setUp() {
+			uuidConverterMockedStatic = mockStatic(UUIDConverter.class);
+			uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString()))
+					.thenReturn(IdentifikationObjektTypeTestFactory.ID);
+		}
+
+		@AfterEach
+		void tearDown() {
+			uuidConverterMockedStatic.close();
+		}
+
+		@Test
+		void shouldConvertOzgFileId() {
+			builder.createKommentarAttachmentIdentifikation(OzgFileTestFactory.create());
+
+			uuidConverterMockedStatic.verify(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString()));
+		}
+
+		@Test
+		void shouldHaveId() {
+			var identifikation = builder.createKommentarAttachmentIdentifikation(OzgFileTestFactory.create());
+
+			assertThat(identifikation.getID()).isEqualTo(IdentifikationObjektTypeTestFactory.ID);
+		}
+	}
+
+	@Nested
+	class TestCreateAnlage {
+
+		private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+		private final OzgFile ozgFile = OzgFileTestFactory.create();
+		private final VersionType version = VersionTypeTestFactory.create();
+
+		@BeforeEach
+		void setUp() {
+			doReturn(identifikationObjektType).when(builder).createKommentarAttachmentIdentifikation(ozgFile);
+			doReturn(version).when(builder).createVersionType(ozgFile);
+		}
+
+		@Test
+		void shouldCreateIdentifikation() {
+			builder.createAnlage(ozgFile);
+
+			verify(builder).createKommentarAttachmentIdentifikation(ozgFile);
+		}
+
+		@Test
+		void shouldHaveIdentifikation() {
+			var anlage = builder.createAnlage(ozgFile);
+
+			assertThat(anlage.getIdentifikation()).isEqualTo(identifikationObjektType);
+		}
+
+		@Test
+		void shouldCreateVersion() {
+			builder.createAnlage(ozgFile);
+
+			verify(builder).createVersionType(ozgFile);
+		}
+
+		@Test
+		void shouldHaveVersion() {
+			var anlage = builder.createAnlage(ozgFile);
+
+			assertThat(anlage.getVersion()).contains(version);
+		}
+	}
+
+	@Nested
+	class TestCreateFormatType {
+
+		private MockedStatic<PrimaerdokumentTypeBuilder> primaerdokumentTypeBuilderMockedStatic;
+		@Mock
+		private PrimaerdokumentTypeBuilder primaerdokumentTypeBuilder;
+
+		private final OzgFile ozgFile = OzgFileTestFactory.create();
+		private final DateiformatCodeType dateiformatCodeType = DateiformatCodeTypeTestFactory.create();
+
+		@BeforeEach
+		void setUp() {
+			primaerdokumentTypeBuilderMockedStatic = mockStatic(PrimaerdokumentTypeBuilder.class);
+			primaerdokumentTypeBuilderMockedStatic.when(PrimaerdokumentTypeBuilder::builder).thenReturn(primaerdokumentTypeBuilder);
+			when(primaerdokumentTypeBuilder.withOzgFile(ozgFile)).thenReturn(primaerdokumentTypeBuilder);
+			doReturn(dateiformatCodeType).when(builder).createDateiformatCodeType(ozgFile);
+		}
+
+		@AfterEach
+		void tearDown() {
+			primaerdokumentTypeBuilderMockedStatic.close();
+		}
+
+		@Test
+		void shouldBuildPrimaerdokument() {
+			builder.createFormatType(ozgFile);
+
+			verify(primaerdokumentTypeBuilder).build();
+		}
+
+		@Test
+		void shouldSetOzgFile() {
+			builder.createFormatType(ozgFile);
+
+			verify(primaerdokumentTypeBuilder).withOzgFile(ozgFile);
+		}
+
+		@Test
+		void shouldSetDatumUhrzeit() {
+			var formatType = builder.createFormatType(ozgFile);
+
+			assertThat(formatType.getVersion()).isEmpty();
+		}
+
+		@Test
+		void shouldCreateDateiformatCode() {
+			builder.createFormatType(ozgFile);
+
+			verify(builder).createDateiformatCodeType(ozgFile);
+		}
+
+		@Test
+		void shouldHaveName() {
+			var formatType = builder.createFormatType(ozgFile);
+
+			assertThat(formatType.getName()).isEqualTo(dateiformatCodeType);
+		}
+	}
+
+	@Nested
+	class TestCreateVersionType {
+
+		private final OzgFile ozgFile = OzgFileTestFactory.create();
+		private final FormatType formatType = FormatTypeTestFactory.create();
+
+		@BeforeEach
+		void setUp() {
+			doReturn(formatType).when(builder).createFormatType(ozgFile);
+		}
+
+		@Test
+		void shouldHaveNummer() {
+			var version = builder.createVersionType(ozgFile);
+
+			assertThat(version.getNummer()).isEqualTo(DokumentTypeBuilder.VERSION_NUMMER);
+		}
+
+		@Test
+		void shouldCreateFormaType() {
+			builder.createVersionType(ozgFile);
+
+			verify(builder).createFormatType(ozgFile);
+		}
+
+		@Test
+		void shouldHaveFormatType() {
+			var version = builder.createVersionType(ozgFile);
+
+			assertThat(version.getFormat()).contains(formatType);
+		}
+	}
+
+	@Nested
+	class TestCreateDateiformatCodeType {
+
+		private static final String CODE = "111";
+
+		private MockedStatic<DateiformatCode> dateiformatCodeMockedStatic;
+
+		@BeforeEach
+		void setUp() {
+			dateiformatCodeMockedStatic = mockStatic(DateiformatCode.class);
+			dateiformatCodeMockedStatic.when(
+							() -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(OzgFileTestFactory.NAME)))
+					.thenReturn(CODE);
+		}
+
+		@AfterEach
+		void tearDown() {
+			dateiformatCodeMockedStatic.close();
+		}
+
+		@Test
+		void shouldHaveListURI() {
+			var dateiformatCode = builder.createDateiformatCodeType(OzgFileTestFactory.create());
+
+			assertThat(dateiformatCode.getListURI()).isEqualTo(DokumentTypeBuilder.DATEI_FORMAT_LIST_URI);
+		}
+
+		@Test
+		void shouldGetXdomeaCode() {
+			builder.createDateiformatCodeType(OzgFileTestFactory.create());
+
+			dateiformatCodeMockedStatic.verify(
+					() -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(OzgFileTestFactory.NAME)));
+		}
+
+		@Test
+		void shouldHaveCode() {
+			var dateiformatCode = builder.createDateiformatCodeType(OzgFileTestFactory.create());
+
+			assertThat(dateiformatCode.getCode()).isEqualTo(CODE);
+		}
+	}
+
+}
\ No newline at end of file

alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java

+package de.ozgcloud.alfa.kommentar;
+
+import static de.ozgcloud.alfa.common.TestUtils.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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 de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportKommentarServiceTest {
+
+	@InjectMocks
+	private ExportKommentarService service;
+
+	@Mock
+	private KommentarService kommentarService;
+	@Mock
+	private BinaryFileService binaryFileService;
+
+	@Nested
+	class TestCreateDokumentTypes {
+
+		private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+
+		private final Kommentar kommentar = KommentarTestFactory.create();
+		private final List<OzgFile> ozgFiles = List.of(OzgFileTestFactory.create());
+		private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+
+		@Mock
+		private DokumentTypeBuilder dokumentTypeBuilder;
+
+		@BeforeEach
+		void setUp() {
+			when(kommentarService.findByVorgangId(VorgangHeaderTestFactory.ID)).thenReturn(Stream.of(kommentar));
+
+			dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+			dokumentTypeBuilderMockedStatic.when(DokumentTypeBuilder::builder).thenReturn(dokumentTypeBuilder);
+			when(dokumentTypeBuilder.withKommentarAttachments(ozgFiles)).thenReturn(dokumentTypeBuilder);
+			when(dokumentTypeBuilder.withKommentar(kommentar)).thenReturn(dokumentTypeBuilder);
+			when(dokumentTypeBuilder.build()).thenReturn(dokumentType);
+
+			mockStreamToList(ozgFiles, stream -> when(binaryFileService.getFiles(KommentarTestFactory.ATTACHMENTS)).thenReturn(stream));
+		}
+
+		@AfterEach
+		void tearDown() {
+			dokumentTypeBuilderMockedStatic.close();
+		}
+
+		@Test
+		void shouldLoadKommentare() {
+			service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+			verify(kommentarService).findByVorgangId(VorgangHeaderTestFactory.ID);
+		}
+
+		@Test
+		void shouldLoadOzgFilesForKommentareAttachments() {
+			service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+			verify(binaryFileService).getFiles(KommentarTestFactory.ATTACHMENTS);
+		}
+
+		@Test
+		void shouldBuildDokumentType() {
+			service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+			verify(dokumentTypeBuilder).build();
+		}
+
+		@Test
+		void shouldSetOzgFile() {
+			service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+			verify(dokumentTypeBuilder).withKommentarAttachments(ozgFiles);
+		}
+
+		@Test
+		void shouldSetKommentar() {
+			service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+			verify(dokumentTypeBuilder).withKommentar(kommentar);
+		}
+	}
+
+}
\ No newline at end of file