diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java
index e47a7eb2ac47d2380c2b07484122c89e9ac6b86e..5cd4aff65c9effe27e31907215043143e2123e5b 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java
@@ -13,13 +13,13 @@ class AbgabeAbgabe0401Creator {
private SchriftgutobjektCreator schriftgutobjektCreator;
@Autowired
- private AnwendungsspezifischeErweiterungMapper anwendungsspezifischeErweiterungMapper;
+ private AnwendungsspezifischeErweiterungTypeCreator anwendungsspezifischeErweiterungTypeCreator;
- public AbgabeAbgabe0401 createAbgabe(VorgangWithEingang vorgang) {
- var erweiterung = anwendungsspezifischeErweiterungMapper.map(vorgang);
+ public AbgabeAbgabe0401 create(VorgangWithEingang vorgang) {
+ var erweiterung = anwendungsspezifischeErweiterungTypeCreator.create(vorgang);
var abgabe = new AbgabeAbgabe0401();
- abgabe.getSchriftgutobjekt().add(schriftgutobjektCreator.createSchriftgutobjekt(vorgang, erweiterung));
+ abgabe.getSchriftgutobjekt().add(schriftgutobjektCreator.create(vorgang, erweiterung));
return abgabe;
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungMapper.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungMapper.java
deleted file mode 100644
index d5ee46e846d26ad3e68a75b8c3f10363f0b3caa7..0000000000000000000000000000000000000000
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungMapper.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import org.mapstruct.Mapper;
-import org.mapstruct.Mapping;
-import org.mapstruct.ReportingPolicy;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
-import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
-
-@Mapper(unmappedTargetPolicy = ReportingPolicy.WARN)
-abstract class AnwendungsspezifischeErweiterungMapper {
-
- @Autowired
- FeldGruppeMapper feldGruppeMapper;
-
- static final String KENNUNG = "IDOZGCloud1234567";
- static final String NAME = "Anwendungsspezifische Erweiterung OZGCloud Basis";
-
- @Mapping(target = "beschreibung", ignore = true)
- @Mapping(target = "versionsdatum", ignore = true)
- @Mapping(target = "versionsnummer", ignore = true)
- @Mapping(target = "feld", ignore = true)
- @Mapping(target = "kennung", constant = KENNUNG)
- @Mapping(target = "name", constant = NAME)
- @Mapping(target = "feldgruppe", expression = "java(List.of(feldGruppeMapper.map(vorgang)))")
- abstract AnwendungsspezifischeErweiterungType map(VorgangWithEingang vorgang);
-}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..d981a15c7542d2ba1e5a46c4094d43bb8e7b9223
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungTypeCreator.java
@@ -0,0 +1,27 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.Collections;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+
+@Component
+class AnwendungsspezifischeErweiterungTypeCreator {
+
+ static final String KENNUNG = "IDOZGCloud1234567";
+ static final String NAME = "Anwendungsspezifische Erweiterung OZGCloud Basis";
+
+ @Autowired
+ private FeldGruppeTypeCreator feldGruppeTypeCreator;
+
+ public AnwendungsspezifischeErweiterungType create(VorgangWithEingang vorgang) {
+ var anwendungsspezifischeErweiterung = new AnwendungsspezifischeErweiterungType();
+ anwendungsspezifischeErweiterung.setKennung(KENNUNG);
+ anwendungsspezifischeErweiterung.setName(NAME);
+ anwendungsspezifischeErweiterung.getFeldgruppe().addAll(Collections.singleton(feldGruppeTypeCreator.create(vorgang)));
+ return anwendungsspezifischeErweiterung;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java
index 240735b34501fe979d02f97e8b45a7f848faf3db..a44e9a8383bdf6088410d5131356b11d739230f2 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java
@@ -1,7 +1,9 @@
package de.ozgcloud.alfa.export;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Stream;
import org.apache.commons.lang3.StringUtils;
@@ -9,6 +11,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.vorgang.Eingang;
import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
import de.xoev.xdomea.AllgemeineMetadatenType;
import de.xoev.xdomea.DokumentType;
@@ -29,8 +32,9 @@ class DokumentTypeCreator {
@Autowired
private VersionTypeCreator versionTypeCreator;
- public Stream<DokumentType> createDokumentTypen(VorgangWithEingang vorgang) {
- var ozgFiles = exportFileService.getAllPdfs(vorgang.getEingang().getId()).toList();
+ public Stream<DokumentType> create(VorgangWithEingang vorgang) {
+ var ozgFiles = Optional.ofNullable(vorgang.getEingang()).map(Eingang::getId).map(exportFileService::getAllPdfs).map(Stream::toList)
+ .orElse(Collections.emptyList());
List<DokumentType> dokumenten = new ArrayList<>(ozgFiles.size());
for (var i = 0; i < ozgFiles.size(); i++) {
dokumenten.add(createDokumentType(i + 1, vorgang, ozgFiles.get(i)));
@@ -42,7 +46,7 @@ class DokumentTypeCreator {
var dokument = new DokumentType();
dokument.setIdentifikation(createIdentifikation(dokumentOrdinalNumber, ozgFile.getId().toString()));
dokument.setAllgemeineMetadaten(createAllgemeineMetadaten(ozgFile));
- dokument.getVersion().add(versionTypeCreator.createVersionType(vorgang, ozgFile));
+ dokument.getVersion().add(versionTypeCreator.create(vorgang, ozgFile));
return dokument;
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FeldGruppeMapper.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FeldGruppeMapper.java
deleted file mode 100644
index af8ec2274178f59b9d24397b25496830a6b17a12..0000000000000000000000000000000000000000
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FeldGruppeMapper.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import java.time.format.DateTimeFormatter;
-import java.util.List;
-
-import org.mapstruct.Mapper;
-import org.mapstruct.Mapping;
-import org.mapstruct.ReportingPolicy;
-
-import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
-import de.xoev.xdomea.FeldType;
-import de.xoev.xdomea.FeldgruppeType;
-
-@Mapper(unmappedTargetPolicy = ReportingPolicy.WARN)
-abstract class FeldGruppeMapper {
-
- static final String NAME = "FeldgruppeOZGCloudBasis";
- static final String BESCHREIBUNG = "Feldgruppe für OZGCloud Basis";
-
- @Mapping(target = "unterfeldgruppe", ignore = true)
- @Mapping(target = "name", constant = NAME)
- @Mapping(target = "beschreibung", constant = BESCHREIBUNG)
- @Mapping(target = "feld", expression = "java(mapToFelder(vorgang))")
- abstract FeldgruppeType map(VorgangWithEingang vorgang);
-
- List<FeldType> mapToFelder(VorgangWithEingang vorgang) {
- return List.of(
- ExportFelder.LEIKA_ID.createFeld(),
- ExportFelder.DATUM_ANTRAGSEINGANG.createFeld(DateTimeFormatter.ISO_DATE_TIME.format(vorgang.getCreatedAt())),
- ExportFelder.NAME.createFeld(vorgang.getEingang().getAntragsteller().getNachname()),
- ExportFelder.VORNAME.createFeld(vorgang.getEingang().getAntragsteller().getVorname()),
- ExportFelder.GEBURTSDATUM.createFeld(vorgang.getEingang().getAntragsteller().getGeburtsdatum()),
- ExportFelder.PLZ.createFeld(vorgang.getEingang().getAntragsteller().getPlz()));
- }
-
-}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FeldGruppeTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FeldGruppeTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..e47cc16c6db59f270bade24eb4389ab91190ba0e
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FeldGruppeTypeCreator.java
@@ -0,0 +1,40 @@
+package de.ozgcloud.alfa.export;
+
+import static java.util.Optional.*;
+
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.FeldType;
+import de.xoev.xdomea.FeldgruppeType;
+
+@Component
+class FeldGruppeTypeCreator {
+
+ static final String NAME = "FeldgruppeOZGCloudBasis";
+ static final String BESCHREIBUNG = "Feldgruppe für OZGCloud Basis";
+
+ public FeldgruppeType create(VorgangWithEingang vorgang) {
+ var feldgruppe = new FeldgruppeType();
+ feldgruppe.setName(NAME);
+ feldgruppe.setBeschreibung(BESCHREIBUNG);
+ feldgruppe.getFeld().addAll(createFeldType(vorgang));
+ return feldgruppe;
+ }
+
+ List<FeldType> createFeldType(VorgangWithEingang vorgang) {
+ var antragsteller = ofNullable(vorgang.getEingang()).flatMap(eingang -> ofNullable(eingang.getAntragsteller()));
+ return List.of(
+ ExportFelder.LEIKA_ID.createFeld(),
+ ExportFelder.DATUM_ANTRAGSEINGANG.createFeld(DateTimeFormatter.ISO_DATE_TIME.format(vorgang.getCreatedAt())),
+ ExportFelder.NAME.createFeld(antragsteller.flatMap(a -> ofNullable(a.getNachname())).orElse(StringUtils.EMPTY)),
+ ExportFelder.VORNAME.createFeld(antragsteller.flatMap(a -> ofNullable(a.getVorname())).orElse(StringUtils.EMPTY)),
+ ExportFelder.GEBURTSDATUM.createFeld(antragsteller.flatMap(a -> ofNullable(a.getGeburtsdatum())).orElse(StringUtils.EMPTY)),
+ ExportFelder.PLZ.createFeld(antragsteller.flatMap(a -> ofNullable(a.getPlz())).orElse(StringUtils.EMPTY)));
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java
index fa96295d753da3780a9f9f7ed5f6639309ac5034..c3d9deb3c1f34c36abc1824ab918ac8b12260d4e 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java
@@ -14,9 +14,9 @@ class FormatTypeCreator {
@Autowired
private PrimaerdokumentTypeCreator primaerdokumentTypeCreator;
- public FormatType createFormatType(VorgangWithEingang vorgang, OzgFile ozgFile) {
+ public FormatType create(VorgangWithEingang vorgang, OzgFile ozgFile) {
var format = new FormatType();
- format.setPrimaerdokument(primaerdokumentTypeCreator.createPrimaerdokumentType(vorgang, ozgFile));
+ format.setPrimaerdokument(primaerdokumentTypeCreator.create(vorgang, ozgFile));
format.setName(DateiformatCode.PDF.createDateiformatCodeType());
format.setSonstigerName(StringUtils.EMPTY);
format.setVersion(StringUtils.EMPTY);
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java
index eb2878a6743cb451eae8412552e5ca2be7725f30..d1fb7a35542796cc1cfe465edb13f9852d50fd1d 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java
@@ -13,7 +13,7 @@ class PrimaerdokumentTypeCreator {
@Autowired
private UUIDConverter uuidConverter;
- public PrimaerdokumentType createPrimaerdokumentType(VorgangWithEingang vorgang, OzgFile ozgFile) {
+ public PrimaerdokumentType create(VorgangWithEingang vorgang, OzgFile ozgFile) {
var primaerdokument = new PrimaerdokumentType();
primaerdokument.setDateiname(createDateiname(ozgFile));
primaerdokument.setDateinameOriginal(ozgFile.getName());
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java
index aa49273d7ff0b1bb012ecf2f900fb31f456f792a..2ba904f2ceb9027f3d14d96736d0219242361b3f 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java
@@ -13,9 +13,9 @@ class SchriftgutobjektCreator {
@Autowired
private VorgangTypeCreator vorgangTypeCreator;
- public Schriftgutobjekt createSchriftgutobjekt(VorgangWithEingang vorgang, AnwendungsspezifischeErweiterungType erweiterung) {
+ public Schriftgutobjekt create(VorgangWithEingang vorgang, AnwendungsspezifischeErweiterungType erweiterung) {
var schritftgutobjekt = new Schriftgutobjekt();
- schritftgutobjekt.setVorgang(vorgangTypeCreator.createVorgangType(vorgang, erweiterung));
+ schritftgutobjekt.setVorgang(vorgangTypeCreator.create(vorgang, erweiterung));
return schritftgutobjekt;
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java
index ca91a6714794dce0261877e75540dcd46f29fc14..7ce323a415aa2181efcd27795de794d256f61b41 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java
@@ -15,10 +15,10 @@ class VersionTypeCreator {
@Autowired
private FormatTypeCreator formatTypeCreator;
- public VersionType createVersionType(VorgangWithEingang vorgang, OzgFile ozgFile) {
+ public VersionType create(VorgangWithEingang vorgang, OzgFile ozgFile) {
var version = new VersionType();
version.setNummer(NUMMER);
- version.getFormat().add(formatTypeCreator.createFormatType(vorgang, ozgFile));
+ version.getFormat().add(formatTypeCreator.create(vorgang, ozgFile));
return version;
}
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java
index 3dc73649b576bed5ca7f349c0b79b27152025fa0..6fd299fbea09cdd2bfcbe25324412bc7cf14f930 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java
@@ -22,12 +22,12 @@ class VorgangTypeCreator {
@Autowired
private DokumentTypeCreator dokumentTypeCreator;
- public VorgangType createVorgangType(VorgangWithEingang vorgangWithEingang, AnwendungsspezifischeErweiterungType erweiterung) {
+ public VorgangType create(VorgangWithEingang vorgangWithEingang, AnwendungsspezifischeErweiterungType erweiterung) {
var vorgang = new VorgangType();
vorgang.setAnwendungsspezifischeErweiterung(erweiterung);
vorgang.setIdentifikation(createIdentifikation());
vorgang.setAllgemeineMetadaten(createAllgemeineMetadaten(vorgangWithEingang));
- vorgang.getDokument().addAll(dokumentTypeCreator.createDokumentTypen(vorgangWithEingang).toList());
+ vorgang.getDokument().addAll(dokumentTypeCreator.create(vorgangWithEingang).toList());
return vorgang;
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java
index e138d057359e76396ab7d09463c8ee81dcfd5962..876ba4dbc7f8a21a2ebfb3049deb0c4df1b841c7 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java
@@ -31,10 +31,13 @@ class XDomeaService {
public void writeExport(String vorgangId, String filenameId, OutputStream out) {
var vorgang = vorgangController.getVorgang(vorgangId);
+ var fileName = buildXmlFilename(filenameId);
+ var xmlContent = createXmlContent(vorgang);
+
try (var zipOutputStream = new ZipOutputStream(out)) {
- putZipEntry(buildXmlFilename(filenameId), createXmlContent(vorgang), zipOutputStream);
- } catch (IOException ioe) {
- throw new TechnicalException("Error creating XDomea zip file", ioe);
+ putZipEntry(fileName, xmlContent, zipOutputStream);
+ } catch (Exception e) {
+ throw new TechnicalException("Error creating XDomea zip file", e);
}
}
@@ -50,6 +53,6 @@ class XDomeaService {
}
String createXmlContent(VorgangWithEingang vorgang) {
- return xDomeaXmlMarshaller.marshal(abgabeCreator.createAbgabe(vorgang));
+ return xDomeaXmlMarshaller.marshal(abgabeCreator.create(vorgang));
}
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java
index fb9780158500c6922aa7e5a05e369e80abaedcb0..f34a7d3b963dfdcecd235f52e49cbf94d6de6bb9 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java
@@ -23,10 +23,10 @@ class AbgabeAbgabe0401CreatorTest {
private SchriftgutobjektCreator schriftgutobjektCreator;
@Mock
- private AnwendungsspezifischeErweiterungMapper anwendungsspezifischeErweiterungMapper;
+ private AnwendungsspezifischeErweiterungTypeCreator anwendungsspezifischeErweiterungTypeCreator;
@Nested
- class TestCreateAbgabe {
+ class TestCreate {
private final VorgangWithEingang vorgangWithEingang = VorgangWithEingangTestFactory.create();
@@ -35,28 +35,29 @@ class AbgabeAbgabe0401CreatorTest {
@BeforeEach
void init() {
- when(anwendungsspezifischeErweiterungMapper.map(vorgangWithEingang)).thenReturn(anwendungsspezifischeErweiterung);
+ when(anwendungsspezifischeErweiterungTypeCreator.create(vorgangWithEingang)).thenReturn(
+ anwendungsspezifischeErweiterung);
}
@Test
void shouldCallMapper() {
- creator.createAbgabe(vorgangWithEingang);
+ creator.create(vorgangWithEingang);
- verify(anwendungsspezifischeErweiterungMapper).map(vorgangWithEingang);
+ verify(anwendungsspezifischeErweiterungTypeCreator).create(vorgangWithEingang);
}
@Test
void shouldCreateSchriftgutobjekt() {
- creator.createAbgabe(vorgangWithEingang);
+ creator.create(vorgangWithEingang);
- verify(schriftgutobjektCreator).createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ verify(schriftgutobjektCreator).create(vorgangWithEingang, anwendungsspezifischeErweiterung);
}
@Test
void shouldHaveSchriftgutobjekt() {
- doReturn(schriftgutobjekt).when(schriftgutobjektCreator).createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ doReturn(schriftgutobjekt).when(schriftgutobjektCreator).create(vorgangWithEingang, anwendungsspezifischeErweiterung);
- var abgabe = creator.createAbgabe(vorgangWithEingang);
+ var abgabe = creator.create(vorgangWithEingang);
assertThat(abgabe.getSchriftgutobjekt().get(0)).isEqualTo(schriftgutobjekt);
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungMapperTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungMapperTest.java
deleted file mode 100644
index b8678afc8b4cd313b334831f1d42d8ce1ddf070f..0000000000000000000000000000000000000000
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungMapperTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.mapstruct.factory.Mappers;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-
-import de.ozgcloud.alfa.export.AnwendungsspezifischeErweiterungMapper;
-import de.ozgcloud.alfa.export.FeldGruppeMapper;
-import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
-import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
-import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
-import de.xoev.xdomea.FeldgruppeType;
-
-class AnwendungsspezifischeErweiterungMapperTest {
-
- @InjectMocks
- private AnwendungsspezifischeErweiterungMapper mapper = Mappers.getMapper(AnwendungsspezifischeErweiterungMapper.class);
-
- @Mock
- private FeldGruppeMapper feldGruppeMapper;
-
- @Nested
- class TestMap {
-
- private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
- private FeldgruppeType feldgruppeType;
-
- @BeforeEach
- void init() {
- feldgruppeType = new FeldgruppeType();
- when(feldGruppeMapper.map(vorgang)).thenReturn(feldgruppeType);
- }
-
- @Test
- void shouldHaveKennung() {
- var mapped = callMapper();
-
- assertThat(mapped.getKennung()).isEqualTo(AnwendungsspezifischeErweiterungMapper.KENNUNG);
- }
-
- @Test
- void shouldHaveName() {
- var mapped = callMapper();
-
- assertThat(mapped.getName()).isEqualTo(AnwendungsspezifischeErweiterungMapper.NAME);
- }
-
- @Test
- void shouldCallFeldgrupperMapper() {
- callMapper();
-
- verify(feldGruppeMapper).map(vorgang);
- }
-
- @Test
- void shouldHaveFeldGruppe() {
- var mapped = callMapper();
-
- assertThat(mapped.getFeldgruppe()).hasSize(1).first().isEqualTo(feldgruppeType);
- }
-
- private AnwendungsspezifischeErweiterungType callMapper() {
- return mapper.map(vorgang);
- }
- }
-
-}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..db766c5063ef4154d736187bad2d8326211b6483
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AnwendungsspezifischeErweiterungTypeCreatorTest.java
@@ -0,0 +1,71 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+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.Spy;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import de.xoev.xdomea.FeldgruppeType;
+
+class AnwendungsspezifischeErweiterungTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private AnwendungsspezifischeErweiterungTypeCreator creator;
+
+ @Mock
+ private FeldGruppeTypeCreator feldGruppeTypeCreator;
+
+ @Nested
+ class TestCreate {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final FeldgruppeType feldgruppeType = new FeldgruppeType();
+
+ @BeforeEach
+ void init() {
+ when(feldGruppeTypeCreator.create(vorgang)).thenReturn(feldgruppeType);
+ }
+
+ @Test
+ void shouldHaveKennung() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getKennung()).isEqualTo(AnwendungsspezifischeErweiterungTypeCreator.KENNUNG);
+ }
+
+ @Test
+ void shouldHaveName() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getName()).isEqualTo(AnwendungsspezifischeErweiterungTypeCreator.NAME);
+ }
+
+ @Test
+ void shouldCallFeldgrupperMapper() {
+ create();
+
+ verify(feldGruppeTypeCreator).create(vorgang);
+ }
+
+ @Test
+ void shouldHaveFeldGruppe() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getFeldgruppe()).hasSize(1).first().isEqualTo(feldgruppeType);
+ }
+
+ private AnwendungsspezifischeErweiterungType create() {
+ return creator.create(vorgang);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java
index 743f719d02220b470dc129ad4151a68f4c8a8b17..0bf790c21d424b1c64d84ffe28a6e076287872a6 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java
@@ -40,28 +40,49 @@ class DokumentTypeCreatorTest {
private VersionTypeCreator versionTypeCreator;
@Nested
- class CreateDokumentTypen {
+ class TestCreate {
- private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
- private final OzgFile ozgFile = OzgFileTestFactory.create();
+ @Nested
+ class WhenAllVorgangDataAvailable {
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
- @BeforeEach
- void init() {
- when(exportFileService.getAllPdfs(EingangTestFactory.ID)).thenReturn(Stream.of(ozgFile));
- }
+ @BeforeEach
+ void init() {
+ when(exportFileService.getAllPdfs(EingangTestFactory.ID)).thenReturn(Stream.of(ozgFile));
+ }
- @Test
- void shouldLoadlAllPdfs() {
- creator.createDokumentTypen(vorgang);
+ @Test
+ void shouldLoadlAllPdfs() {
+ creator.create(vorgang);
- verify(exportFileService).getAllPdfs(EingangTestFactory.ID);
+ verify(exportFileService).getAllPdfs(EingangTestFactory.ID);
+ }
+
+ @Test
+ void shouldCreateDokumentType() {
+ creator.create(vorgang);
+
+ verify(creator).createDokumentType(1, vorgang, ozgFile);
+ }
}
- @Test
- void shouldCreateDokumentType() {
- creator.createDokumentTypen(vorgang);
+ @Nested
+ class WhenEingangIsNull {
+
+ @Test
+ void shouldNotLoadAnyPdf() {
+ creator.create(VorgangWithEingang.builder().eingang(null).build());
+
+ verify(exportFileService, never()).getAllPdfs(EingangTestFactory.ID);
+ }
+
+ @Test
+ void shouldReturnEmptyStreamIfEingangNull() {
+ var result = creator.create(VorgangWithEingang.builder().eingang(null).build());
- verify(creator).createDokumentType(1, vorgang, ozgFile);
+ assertThat(result).isEmpty();
+ }
}
}
@@ -81,7 +102,7 @@ class DokumentTypeCreatorTest {
doReturn(identifikationObjekt).when(creator).createIdentifikation(DOKUMENT_ORDINAL_NUMBER, OzgFileTestFactory.ID.toString());
doReturn(allgemeineMetadaten).when(creator).createAllgemeineMetadaten(ozgFile);
- when(versionTypeCreator.createVersionType(vorgang, ozgFile)).thenReturn(version);
+ when(versionTypeCreator.create(vorgang, ozgFile)).thenReturn(version);
}
@Test
@@ -116,7 +137,7 @@ class DokumentTypeCreatorTest {
void shouldCreateVersion() {
create();
- verify(versionTypeCreator).createVersionType(vorgang, ozgFile);
+ verify(versionTypeCreator).create(vorgang, ozgFile);
}
@Test
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FeldGruppeMapperTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FeldGruppeMapperTest.java
deleted file mode 100644
index 615b82eb51b1200c527e58d7838419e423a1c17b..0000000000000000000000000000000000000000
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FeldGruppeMapperTest.java
+++ /dev/null
@@ -1,415 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-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.mapstruct.factory.Mappers;
-
-import de.ozgcloud.alfa.export.DatentypCode;
-import de.ozgcloud.alfa.export.ExportFelder;
-import de.ozgcloud.alfa.export.FeldGruppeMapper;
-import de.ozgcloud.alfa.vorgang.AntragstellerTestFactory;
-import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
-import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
-import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
-import de.xoev.xdomea.DatentypCodeType;
-import de.xoev.xdomea.FeldType;
-
-class FeldGruppeMapperTest {
-
- private FeldGruppeMapper mapper = Mappers.getMapper(FeldGruppeMapper.class);
-
- @DisplayName("Map")
- @Nested
- class TestMap {
-
- private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
-
- @Test
- void shouldHaveName() {
- var mapped = mapper.map(vorgang);
-
- assertThat(mapped.getName()).isEqualTo("FeldgruppeOZGCloudBasis");
- }
-
- @Test
- void shouldHaveBeschreibung() {
- var mapped = mapper.map(vorgang);
-
- assertThat(mapped.getBeschreibung()).isEqualTo("Feldgruppe für OZGCloud Basis");
- }
- }
-
- @DisplayName("Map to felder")
- @Nested
- class TestMapToFelder {
-
- private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
-
- @DisplayName("LeikaId")
- @Nested
- class TestLeikaId {
-
- @Test
- void shouldHaveName() {
- var mapped = mapLeikaID();
-
- assertThat(mapped).extracting(FeldType::getName).isEqualTo("LeikaID");
- }
-
- @Test
- void shouldHaveBeschreibung() {
- var mapped = mapLeikaID();
-
- assertThat(mapped).extracting(FeldType::getBeschreibung).isEqualTo("ID einer Leistung aus dem OZG-Leistungskatalog");
- }
-
- @Test
- void shouldHaveWert() {
- var mapped = mapLeikaID();
-
- assertThat(mapped).extracting(FeldType::getWert).isNull();
- }
-
- @DisplayName("DatentypCode")
- @Nested
- class TestDatentypCode {
-
- @Test
- void shouldHaveCode() {
- var mapped = mapLeikaID();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
- .isEqualTo(DatentypCode.STRING.getCode());
- }
-
- @Test
- void shouldHaveListURI() {
- var mapped = mapLeikaID();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
- .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
- }
-
- @Test
- void shouldHaveListVersionID() {
- var mapped = mapLeikaID();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
- }
-
- }
-
- private FeldType mapLeikaID() {
- return mapper.mapToFelder(vorgang).stream()
- .filter(feldType -> feldType.getName().equals(ExportFelder.LEIKA_ID.getName()))
- .toList().get(0);
- }
- }
-
- @DisplayName("Datum Antragseingang")
- @Nested
- class TestDatumAntragseingang {
-
- @Test
- void shouldHaveName() {
- var mapped = mapDatumAntragseingang();
-
- assertThat(mapped).extracting(FeldType::getName).isEqualTo("DatumAntragseingang");
- }
-
- @Test
- void shouldHaveBeschreibung() {
- var mapped = mapDatumAntragseingang();
-
- assertThat(mapped).extracting(FeldType::getBeschreibung).isEqualTo("Das Datum des Antragseingangs");
- }
-
- @Test
- void shouldHaveWert() {
- var mapped = mapDatumAntragseingang();
-
- assertThat(mapped).extracting(FeldType::getWert).isEqualTo(VorgangHeaderTestFactory.CREATED_AT_STR);
- }
-
- @DisplayName("DatentypCode")
- @Nested
- class TestDatentypCode {
-
- @Test
- void shouldHaveCode() {
- var mapped = mapDatumAntragseingang();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode).isEqualTo(DatentypCode.DATE.getCode());
- }
-
- @Test
- void shouldHaveListURI() {
- var mapped = mapDatumAntragseingang();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
- .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
- }
-
- @Test
- void shouldHaveListVersionID() {
- var mapped = mapDatumAntragseingang();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
- }
-
- }
-
- private FeldType mapDatumAntragseingang() {
- return mapper.mapToFelder(vorgang).stream()
- .filter(feldType -> feldType.getName().equals(ExportFelder.DATUM_ANTRAGSEINGANG.getName()))
- .toList().get(0);
- }
- }
-
- @DisplayName("Name")
- @Nested
- class TestName {
-
- @Test
- void shouldHaveName() {
- var mapped = mapName();
-
- assertThat(mapped).extracting(FeldType::getName).isEqualTo("Name");
- }
-
- @Test
- void shouldNotHaveBeschreibung() {
- var mapped = mapName();
-
- assertThat(mapped).extracting(FeldType::getBeschreibung).isNull();
- }
-
- @Test
- void shouldHaveWert() {
- var mapped = mapName();
-
- assertThat(mapped).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.NACHNAME);
- }
-
- @DisplayName("DatentypCode")
- @Nested
- class TestDatentypCode {
-
- @Test
- void shouldHaveCode() {
- var mapped = mapName();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
- .isEqualTo(DatentypCode.STRING.getCode());
- }
-
- @Test
- void shouldHaveListURI() {
- var mapped = mapName();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
- .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
- }
-
- @Test
- void shouldHaveListVersionID() {
- var mapped = mapName();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
- }
-
- }
-
- private FeldType mapName() {
- return mapper.mapToFelder(vorgang).stream()
- .filter(feldType -> feldType.getName().equals(ExportFelder.NAME.getName()))
- .toList().get(0);
- }
- }
-
- @DisplayName("Vorname")
- @Nested
- class TestVorname {
-
- @Test
- void shouldHaveName() {
- var mapped = mapVorname();
-
- assertThat(mapped).extracting(FeldType::getName).isEqualTo("Vorname");
- }
-
- @Test
- void shouldHaveNotHaveBeschreibung() {
- var mapped = mapVorname();
-
- assertThat(mapped).extracting(FeldType::getBeschreibung).isNull();
- }
-
- @Test
- void shouldHaveWert() {
- var mapped = mapVorname();
-
- assertThat(mapped).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.VORNAME);
- }
-
- @DisplayName("DatentypCode")
- @Nested
- class TestDatentypCode {
-
- @Test
- void shouldHaveCode() {
- var mapped = mapVorname();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
- .isEqualTo(DatentypCode.STRING.getCode());
- }
-
- @Test
- void shouldHaveListURI() {
- var mapped = mapVorname();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
- .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
- }
-
- @Test
- void shouldHaveListVersionID() {
- var mapped = mapVorname();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
- }
-
- }
-
- private FeldType mapVorname() {
- return mapper.mapToFelder(vorgang).stream()
- .filter(feldType -> feldType.getName().equals(ExportFelder.VORNAME.getName()))
- .toList().get(0);
- }
- }
-
- @DisplayName("Geburtsdatum")
- @Nested
- class TestGeburtsdatum {
-
- @Test
- void shouldHaveName() {
- var mapped = mapGeburtsdatum();
-
- assertThat(mapped).extracting(FeldType::getName).isEqualTo("Geburtsdatum");
- }
-
- @Test
- void shouldHaveNotHaveBeschreibung() {
- var mapped = mapGeburtsdatum();
-
- assertThat(mapped).extracting(FeldType::getBeschreibung).isNull();
- }
-
- @Test
- void shouldHaveWert() {
- var mapped = mapGeburtsdatum();
-
- assertThat(mapped).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.GEBURTSDATUM_STR);
- }
-
- @DisplayName("DatentypCode")
- @Nested
- class TestDatentypCode {
-
- @Test
- void shouldHaveCode() {
- var mapped = mapGeburtsdatum();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode).isEqualTo(DatentypCode.DATE.getCode());
- }
-
- @Test
- void shouldHaveListURI() {
- var mapped = mapGeburtsdatum();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
- .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
- }
-
- @Test
- void shouldHaveListVersionID() {
- var mapped = mapGeburtsdatum();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
- }
-
- }
-
- private FeldType mapGeburtsdatum() {
- return mapper.mapToFelder(vorgang).stream()
- .filter(feldType -> feldType.getName().equals(ExportFelder.GEBURTSDATUM.getName()))
- .toList().get(0);
- }
- }
-
- @DisplayName("Plz")
- @Nested
- class TestPlz {
-
- @Test
- void shouldHaveName() {
- var mapped = mapPlz();
-
- assertThat(mapped).extracting(FeldType::getName).isEqualTo("PLZAntragsteller");
- }
-
- @Test
- void shouldHaveNotHaveBeschreibung() {
- var mapped = mapPlz();
-
- assertThat(mapped).extracting(FeldType::getBeschreibung).isNull();
- }
-
- @Test
- void shouldHaveWert() {
- var mapped = mapPlz();
-
- assertThat(mapped).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.PLZ);
- }
-
- @DisplayName("DatentypCode")
- @Nested
- class TestDatentypCode {
-
- @Test
- void shouldHaveCode() {
- var mapped = mapPlz();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
- .isEqualTo(DatentypCode.STRING.getCode());
- }
-
- @Test
- void shouldHaveListURI() {
- var mapped = mapPlz();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
- .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
- }
-
- @Test
- void shouldHaveListVersionID() {
- var mapped = mapPlz();
-
- assertThat(mapped).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
- }
-
- }
-
- private FeldType mapPlz() {
- return mapper.mapToFelder(vorgang).stream()
- .filter(feldType -> feldType.getName().equals(ExportFelder.PLZ.getName()))
- .toList().get(0);
- }
- }
- }
-}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FeldGruppeTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FeldGruppeTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..95027d111a4d367dcdfa559b31a28c4ceea41491
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FeldGruppeTypeCreatorTest.java
@@ -0,0 +1,531 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.vorgang.AntragstellerTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DatentypCodeType;
+import de.xoev.xdomea.FeldType;
+
+class FeldGruppeTypeCreatorTest {
+
+ @Spy
+ private FeldGruppeTypeCreator creator;
+
+ @Nested
+ class TestCreate {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @Test
+ void shouldHaveName() {
+ var created = creator.create(vorgang);
+
+ assertThat(created.getName()).isEqualTo("FeldgruppeOZGCloudBasis");
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ var created = creator.create(vorgang);
+
+ assertThat(created.getBeschreibung()).isEqualTo("Feldgruppe für OZGCloud Basis");
+ }
+
+ @Test
+ void shouldCreateFeldType() {
+ creator.create(vorgang);
+
+ verify(creator).createFeldType(vorgang);
+ }
+ }
+
+ @Nested
+ class TestCreateFeldType {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @DisplayName("LeikaId")
+ @Nested
+ class TestLeikaId {
+
+ @Test
+ void shouldHaveName() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("LeikaID");
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isEqualTo("ID einer Leistung aus dem OZG-Leistungskatalog");
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getWert).isNull();
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create() {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.LEIKA_ID.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Datum Antragseingang")
+ @Nested
+ class TestDatumAntragseingang {
+
+ @Test
+ void shouldHaveName() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("DatumAntragseingang");
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isEqualTo("Das Datum des Antragseingangs");
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(VorgangHeaderTestFactory.CREATED_AT_STR);
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.DATE.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create() {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.DATUM_ANTRAGSEINGANG.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Name")
+ @Nested
+ class TestName {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("Name");
+ }
+
+ @Test
+ void shouldNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.NACHNAME);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullNachname() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().nachname(null).build())
+ .build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.NAME.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Vorname")
+ @Nested
+ class TestVorname {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("Vorname");
+ }
+
+ @Test
+ void shouldHaveNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.VORNAME);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullVorname() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().vorname(null).build())
+ .build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.VORNAME.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Geburtsdatum")
+ @Nested
+ class TestGeburtsdatum {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("Geburtsdatum");
+ }
+
+ @Test
+ void shouldHaveNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.GEBURTSDATUM_STR);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullGeburtsdatum() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().geburtsdatum(null).build())
+ .build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.DATE.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.GEBURTSDATUM.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Plz")
+ @Nested
+ class TestPlz {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("PLZAntragsteller");
+ }
+
+ @Test
+ void shouldHaveNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.PLZ);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullPlz() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().plz(null).build())
+ .build())
+ .build());
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.PLZ.getName()))
+ .toList().get(0);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java
index e639d7a8bfad0a703077225d6f2a354275669df3..be881eb41bb7ea565008bf5c9d0bcb2f94ba114b 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java
@@ -27,7 +27,7 @@ class FormatTypeCreatorTest {
private PrimaerdokumentTypeCreator primaerdokumentTypeCreator;
@Nested
- class TestCreateFormatType {
+ class TestCreate {
private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
private final OzgFile ozgFile = OzgFileTestFactory.create();
@@ -36,40 +36,40 @@ class FormatTypeCreatorTest {
@BeforeEach
void init() {
- when(primaerdokumentTypeCreator.createPrimaerdokumentType(vorgang, ozgFile)).thenReturn(primaerdokument);
+ when(primaerdokumentTypeCreator.create(vorgang, ozgFile)).thenReturn(primaerdokument);
}
@Test
void shouldCreatePrimaerdokument() {
- creator.createFormatType(vorgang, ozgFile);
+ creator.create(vorgang, ozgFile);
- verify(primaerdokumentTypeCreator).createPrimaerdokumentType(vorgang, ozgFile);
+ verify(primaerdokumentTypeCreator).create(vorgang, ozgFile);
}
@Test
void shouldHavePrimaerdokumentType() {
- var format = creator.createFormatType(vorgang, ozgFile);
+ var format = creator.create(vorgang, ozgFile);
assertThat(format.getPrimaerdokument()).isEqualTo(primaerdokument);
}
@Test
void shouldHaveName() {
- var format = creator.createFormatType(vorgang, ozgFile);
+ var format = creator.create(vorgang, ozgFile);
assertThat(format.getName()).usingRecursiveComparison().isEqualTo(DateiformatCode.PDF.createDateiformatCodeType());
}
@Test
void shouldHaveSonstigerName() {
- var format = creator.createFormatType(vorgang, ozgFile);
+ var format = creator.create(vorgang, ozgFile);
assertThat(format.getSonstigerName()).isEqualTo(StringUtils.EMPTY);
}
@Test
void shouldHaveVersion() {
- var format = creator.createFormatType(vorgang, ozgFile);
+ var format = creator.create(vorgang, ozgFile);
assertThat(format.getVersion()).isEqualTo(StringUtils.EMPTY);
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java
index d2cea2a5a3374289b5f4c2d5b3a5a1bd31d907cc..4446ecacf545501b69dc7b0a45da999411ef8ce2 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java
@@ -27,7 +27,7 @@ class PrimaerdokumentTypeCreatorTest {
private UUIDConverter uuidConverter;
@Nested
- class TestCreatePrimaerdokumentType {
+ class TestCreate {
private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
private final OzgFile ozgFile = OzgFileTestFactory.create();
@@ -39,28 +39,28 @@ class PrimaerdokumentTypeCreatorTest {
@Test
void shouldCreateDateiname() {
- creator.createPrimaerdokumentType(vorgang, ozgFile);
+ creator.create(vorgang, ozgFile);
verify(creator).createDateiname(ozgFile);
}
@Test
void shouldHaveDateiname() {
- var primaerdokument = creator.createPrimaerdokumentType(vorgang, ozgFile);
+ var primaerdokument = creator.create(vorgang, ozgFile);
assertThat(primaerdokument.getDateiname()).isEqualTo(ozgFile.getName());
}
@Test
void shouldHaveDateinameOriginal() {
- var primaerdokument = creator.createPrimaerdokumentType(vorgang, ozgFile);
+ var primaerdokument = creator.create(vorgang, ozgFile);
assertThat(primaerdokument.getDateinameOriginal()).isEqualTo(ozgFile.getName());
}
@Test
void shouldHaveErsteller() {
- var primaerdokument = creator.createPrimaerdokumentType(vorgang, ozgFile);
+ var primaerdokument = creator.create(vorgang, ozgFile);
assertThat(primaerdokument.getErsteller()).isEqualTo(EingangHeaderTestFactory.FORM_ENGINE_NAME);
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java
index 214e6a3a323b1addec2aebe02381a8849e196e34..1ea75ceee7e8b37bf123339fd9fc0ee60503e722 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java
@@ -22,7 +22,7 @@ class SchriftgutobjektCreatorTest {
private VorgangTypeCreator vorgangTypeCreator;
@Nested
- class TestCreateSchriftgutObjekt {
+ class TestCreate {
private final VorgangWithEingang vorgangWithEingang = VorgangWithEingangTestFactory.create();
@@ -31,16 +31,16 @@ class SchriftgutobjektCreatorTest {
@Test
void shouldCreateVorgangType() {
- creator.createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ creator.create(vorgangWithEingang, anwendungsspezifischeErweiterung);
- verify(vorgangTypeCreator).createVorgangType(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ verify(vorgangTypeCreator).create(vorgangWithEingang, anwendungsspezifischeErweiterung);
}
@Test
void shouldHaveVorgangType() {
- doReturn(vorgang).when(vorgangTypeCreator).createVorgangType(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ doReturn(vorgang).when(vorgangTypeCreator).create(vorgangWithEingang, anwendungsspezifischeErweiterung);
- var schriftgutobjekt = creator.createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ var schriftgutobjekt = creator.create(vorgangWithEingang, anwendungsspezifischeErweiterung);
assertThat(schriftgutobjekt.getVorgang()).isEqualTo(vorgang);
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java
index 0a038a493dcb4cd44c7dc4a7c8f131e1ab0aa3d5..bd1f17cb080e3fbc887dbd4cc9cdb6b9dec16f1c 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java
@@ -24,7 +24,7 @@ class VersionTypeCreatorTest {
private FormatTypeCreator formatTypeCreator;
@Nested
- class TestCreateVersionType {
+ class TestCreate {
private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
private final OzgFile ozgFile = OzgFileTestFactory.create();
@@ -32,26 +32,26 @@ class VersionTypeCreatorTest {
@BeforeEach
void init() {
- when(formatTypeCreator.createFormatType(vorgang, ozgFile)).thenReturn(formatType);
+ when(formatTypeCreator.create(vorgang, ozgFile)).thenReturn(formatType);
}
@Test
void shouldHaveNummer() {
- var version = creator.createVersionType(vorgang, ozgFile);
+ var version = creator.create(vorgang, ozgFile);
assertThat(version.getNummer()).isEqualTo(VersionTypeCreator.NUMMER);
}
@Test
void shouldCreateFormatType() {
- creator.createVersionType(vorgang, ozgFile);
+ creator.create(vorgang, ozgFile);
- verify(formatTypeCreator).createFormatType(vorgang, ozgFile);
+ verify(formatTypeCreator).create(vorgang, ozgFile);
}
@Test
void shouldHaveFormatType() {
- var version = creator.createVersionType(vorgang, ozgFile);
+ var version = creator.create(vorgang, ozgFile);
assertThat(version.getFormat()).containsExactly(formatType);
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java
index fb414919b4cb6094a663ac0c8f07328dfdf3d2e4..62cd4dd2e55337719205f5586d24aa3a9234b180 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java
@@ -32,7 +32,7 @@ class VorgangTypeCreatorTest {
private DokumentTypeCreator dokumentTypeCreator;
@Nested
- class TestCreateVorgangType {
+ class TestCreate {
private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
@@ -46,49 +46,49 @@ class VorgangTypeCreatorTest {
doReturn(identifikationObjekt).when(creator).createIdentifikation();
doReturn(allgemeineMetadaten).when(creator).createAllgemeineMetadaten(vorgang);
- when(dokumentTypeCreator.createDokumentTypen(vorgang)).thenReturn(Stream.of(dokument));
+ when(dokumentTypeCreator.create(vorgang)).thenReturn(Stream.of(dokument));
}
@Test
void shouldHaveAnwendungsspezifischeErweiterungType() {
- var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+ var vorgangType = creator.create(vorgang, anwendungsspezifischeErweiterung);
assertThat(vorgangType.getAnwendungsspezifischeErweiterung()).isEqualTo(anwendungsspezifischeErweiterung);
}
@Test
void shouldCallCreateIdentifikation() {
- creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+ creator.create(vorgang, anwendungsspezifischeErweiterung);
verify(creator).createIdentifikation();
}
@Test
void shouldHaveIdentifikation() {
- var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+ var vorgangType = creator.create(vorgang, anwendungsspezifischeErweiterung);
assertThat(vorgangType.getIdentifikation()).isEqualTo(identifikationObjekt);
}
@Test
void shouldCallCreateAllgemeineMetadaten() {
- creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+ creator.create(vorgang, anwendungsspezifischeErweiterung);
verify(creator).createAllgemeineMetadaten(vorgang);
}
@Test
void shouldHaveAllgemeineMetadaten() {
- var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+ var vorgangType = creator.create(vorgang, anwendungsspezifischeErweiterung);
assertThat(vorgangType.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadaten);
}
@Test
void shouldCreateDokumenType() {
- var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+ var vorgangType = creator.create(vorgang, anwendungsspezifischeErweiterung);
- verify(dokumentTypeCreator).createDokumentTypen(vorgang);
+ verify(dokumentTypeCreator).create(vorgang);
assertThat(vorgangType.getDokument()).hasSize(1).containsExactly(dokument);
}
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java
index b6a74793cea29cc43281abbed69c6ebdf64b82aa..9806971136f34f07db8540476255ccb6679d7581 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java
@@ -129,7 +129,7 @@ class XDomeaServiceTest {
@BeforeEach
void init() {
- doReturn(abgabe).when(abgabeCreator).createAbgabe(vorgang);
+ doReturn(abgabe).when(abgabeCreator).create(vorgang);
when(XDomeaXmlMarshaller.marshal(any())).thenReturn(XML_STRING);
}
@@ -151,7 +151,7 @@ class XDomeaServiceTest {
void shouldCallAbgabeCreator() {
service.createXmlContent(vorgang);
- verify(abgabeCreator).createAbgabe(vorgang);
+ verify(abgabeCreator).create(vorgang);
}
}
}
\ No newline at end of file