diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidator.java b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidator.java
new file mode 100644
index 0000000000000000000000000000000000000000..eafbad0b39346f495d20d52f05b770d214a983c5
--- /dev/null
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidator.java
@@ -0,0 +1,75 @@
+package de.ozgcloud.xta.client.xdomea;
+
+import static de.ozgcloud.xta.client.xdomea.mapper.MetadataMapper.*;
+
+import java.util.List;
+import java.util.Set;
+
+import de.ozgcloud.xta.client.exception.ClientException;
+import de.ozgcloud.xta.client.model.XtaFile;
+import de.ozgcloud.xta.client.model.XtaMessageMetaData;
+import de.ozgcloud.xta.client.xdomea.reader.XdomeaXmlValues;
+import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReader;
+import lombok.Builder;
+import lombok.RequiredArgsConstructor;
+
+@Builder
+@RequiredArgsConstructor
+public class XdomeaMetaDataValidator {
+
+ private final ZipFileEntryReader zipFileEntryReader;
+
+ static final String AUTHOR_ID_PREFIX_NAME = "author";
+ static final String READER_ID_PREFIX_NAME = "reader";
+
+ public void validate(
+ XtaFile xdomeaZipFile,
+ XdomeaXmlValues xdomeaXmlValues,
+ XtaMessageMetaData messageMetadataData
+ ) throws ClientException {
+ validateIdentifierPrefixes(
+ xdomeaXmlValues.authorIdPrefix(),
+ xdomeaXmlValues.readerIdPrefix()
+ );
+ validateZipFileName(
+ xdomeaZipFile.name(),
+ xdomeaXmlValues.processId(),
+ messageMetadataData.messageTypeCode()
+ );
+ validatePrimaryDocumentReferences(xdomeaZipFile, xdomeaXmlValues.primaryDocumentNames());
+ }
+
+ void validateIdentifierPrefixes(String authorIdPrefix, String readerIdPrefix) throws ClientException {
+ validateIdentifierPrefix(authorIdPrefix, AUTHOR_ID_PREFIX, AUTHOR_ID_PREFIX_NAME);
+ validateIdentifierPrefix(readerIdPrefix, READER_ID_PREFIX, READER_ID_PREFIX_NAME);
+ }
+
+ void validateIdentifierPrefix(String prefix, String expectedPrefix, String prefixName) throws ClientException {
+ if (!expectedPrefix.equals(normalizePrefix(prefix))) {
+ throw new ClientException("Expect prefix of %s identifier to be '%s'! (actual: %s)".formatted(prefixName, expectedPrefix, prefix));
+ }
+ }
+
+ private String normalizePrefix(String prefix) {
+ return prefix.endsWith(":") ? prefix.substring(0, prefix.length() - 1) : prefix;
+ }
+
+ void validatePrimaryDocumentReferences(XtaFile xdomeaZipFile, List<String> primaryDocumentNames) throws ClientException {
+ var entryNames = Set.copyOf(zipFileEntryReader.getEntryNames(xdomeaZipFile.content()));
+ for (var primaryDocumentName : primaryDocumentNames) {
+ if (!entryNames.contains(primaryDocumentName)) {
+ throw new ClientException("Primary document reference '%s' not found in xdomea zip file!".formatted(primaryDocumentName));
+ }
+ }
+ }
+
+ void validateZipFileName(String xdomeaZipFileName, String processId, String messageTypeCode) throws ClientException {
+ var expectedXdomeaZipFileName = "%s_%s.zip".formatted(processId, messageTypeCode);
+ if (!expectedXdomeaZipFileName.equals(xdomeaZipFileName)) {
+ throw new ClientException(
+ "Expect xdomea zip file name to equal '%s'! (actual: '%s')".formatted(expectedXdomeaZipFileName, xdomeaZipFileName)
+ );
+ }
+ }
+
+}
diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorFactory.java b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..7dbf72ffea697299ac5bfe69b419f41e50469fd4
--- /dev/null
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorFactory.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.xta.client.xdomea;
+
+import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReader;
+import lombok.Builder;
+import lombok.RequiredArgsConstructor;
+
+@Builder
+@RequiredArgsConstructor
+public class XdomeaMetaDataValidatorFactory {
+
+ private final ZipFileEntryReader zipFileEntryReader;
+
+ public XdomeaMetaDataValidator create() {
+ return XdomeaMetaDataValidator.builder()
+ .zipFileEntryReader(zipFileEntryReader)
+ .build();
+ }
+
+}
diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreator.java b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreator.java
index 2ed5f8cb707922f99dd1557a9276ccb7f7d36b5f..2bd66d76bee063031959336990e92acea12daeb2 100644
--- a/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreator.java
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreator.java
@@ -4,8 +4,6 @@ import static java.util.Collections.*;
import java.io.IOException;
import java.io.InputStream;
-import java.util.List;
-import java.util.Set;
import javax.xml.parsers.DocumentBuilder;
@@ -32,6 +30,7 @@ public class XdomeaXtaMessageCreator {
private final DocumentBuilder documentBuilder;
private final MetadataMapper metadataMapper;
private final ZipFileEntryReader zipFileEntryReader;
+ private final XdomeaMetaDataValidator metaDataValidator;
public XtaMessage createMessage(XtaFile xdomeaZipFile) throws ClientException {
return XtaMessage.builder()
@@ -45,36 +44,13 @@ public class XdomeaXtaMessageCreator {
try {
var xdomeaXmlValues = readXdomeaXmlValues(xdomeaZipFile);
var messageMetadataData = metadataMapper.mapXtaMessageMetadata(xdomeaXmlValues);
- validateZipFileName(
- xdomeaZipFile.name(),
- xdomeaXmlValues.processId(),
- messageMetadataData.messageTypeCode()
- );
- validatePrimaryDocumentReferences(xdomeaZipFile, xdomeaXmlValues.primaryDocumentNames());
+ metaDataValidator.validate(xdomeaZipFile, xdomeaXmlValues, messageMetadataData);
return messageMetadataData;
} catch (TechnicalException e) {
throw new ClientException("Failed to derive valid message metadata from xdomea document!", e);
}
}
- void validatePrimaryDocumentReferences(XtaFile xdomeaZipFile, List<String> primaryDocumentNames) throws ClientException {
- var entryNames = Set.copyOf(zipFileEntryReader.getEntryNames(xdomeaZipFile.content()));
- for (var primaryDocumentName : primaryDocumentNames) {
- if (!entryNames.contains(primaryDocumentName)) {
- throw new ClientException("Primary document reference '%s' not found in xdomea zip file!".formatted(primaryDocumentName));
- }
- }
- }
-
- void validateZipFileName(String xdomeaZipFileName, String processId, String messageTypeCode) throws ClientException {
- var expectedXdomeaZipFileName = "%s_%s.zip".formatted(processId, messageTypeCode);
- if (!expectedXdomeaZipFileName.equals(xdomeaZipFileName)) {
- throw new ClientException(
- "Expect xdomea zip file name to equal '%s'! (actual: '%s')".formatted(expectedXdomeaZipFileName, xdomeaZipFileName)
- );
- }
- }
-
XdomeaXmlValues readXdomeaXmlValues(XtaFile xdomeaZipFile) throws ClientException {
var document = readXdomeaXmlDocument(xdomeaZipFile);
return xdomeaValueReader.readValues(document);
diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactory.java b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactory.java
index b3141a7e3fd099dca2911a9d35ad2ce6305219c1..3b6ff6aba506a706aa6c09cc66c6d9a87e1f66bb 100644
--- a/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactory.java
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactory.java
@@ -25,6 +25,7 @@ import org.xml.sax.SAXParseException;
import de.ozgcloud.common.errorhandling.TechnicalException;
import de.ozgcloud.xta.client.xdomea.mapper.MetadataMapper;
import de.ozgcloud.xta.client.xdomea.reader.XdomeaValueReaderFactory;
+import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReader;
import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReaderFactory;
import lombok.Builder;
import lombok.RequiredArgsConstructor;
@@ -48,21 +49,27 @@ public class XdomeaXtaMessageCreatorFactory {
);
private final XdomeaValueReaderFactory xdomeaValueReaderFactory;
- private final ZipFileEntryReaderFactory zipFileEntryReaderFactory;
+ private final ZipFileEntryReader zipFileEntryReader;
private final DocumentBuilderFactory documentBuilderFactory;
private final MetadataMapper metadataMapper;
+ private final XdomeaMetaDataValidatorFactory xdomeaMetaDataValidatorFactory;
private final SchemaFactory schemaFactory;
private final ClassLoader classLoader;
private final ErrorHandler errorHandler;
public static XdomeaXtaMessageCreatorFactory createInstance() {
+ var zipEntryReaderFactory = ZipFileEntryReaderFactory.builder().build();
+ var zipEntryReader = zipEntryReaderFactory.create();
return XdomeaXtaMessageCreatorFactory.builder()
.xdomeaValueReaderFactory(XdomeaValueReaderFactory.builder()
.xPathFactory(createXPathFactory())
.build())
- .zipFileEntryReaderFactory(ZipFileEntryReaderFactory.builder().build())
+ .zipFileEntryReader(zipEntryReader)
.documentBuilderFactory(DocumentBuilderFactory.newInstance())
.metadataMapper(Mappers.getMapper(MetadataMapper.class))
+ .xdomeaMetaDataValidatorFactory(XdomeaMetaDataValidatorFactory.builder()
+ .zipFileEntryReader(zipEntryReader)
+ .build())
.schemaFactory(SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI))
.classLoader(XdomeaXtaMessageCreatorFactory.class.getClassLoader())
.errorHandler(new CustomErrorHandler())
@@ -141,8 +148,9 @@ public class XdomeaXtaMessageCreatorFactory {
return XdomeaXtaMessageCreator.builder()
.documentBuilder(createDocumentBuilder())
.xdomeaValueReader(xdomeaValueReaderFactory.create())
- .zipFileEntryReader(zipFileEntryReaderFactory.create())
+ .zipFileEntryReader(zipFileEntryReader)
.metadataMapper(metadataMapper)
+ .metaDataValidator(xdomeaMetaDataValidatorFactory.create())
.build();
}
}
diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReader.java b/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReader.java
index 45adea934b21aeec30fdb28f5055ed2887f0ddac..8ffa13166a14607379702c97927167f5693ee287 100644
--- a/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReader.java
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReader.java
@@ -17,7 +17,9 @@ public class XdomeaValueReader {
static final String PROCESS_ID_XPATH = getXpath("Kopf", "ProzessID");
static final String AUTHOR_ID_SUFFIX_XPATH = getXpath("Kopf", "Absender", "code");
+ static final String AUTHOR_ID_PREFIX_XPATH = getXpath("Kopf", "Absender", "Praefix", "code");
static final String READER_ID_SUFFIX_XPATH = getXpath("Kopf", "Empfaenger", "code");
+ static final String READER_ID_PREFIX_XPATH = getXpath("Kopf", "Empfaenger", "Praefix", "code");
static final String MESSAGE_TYPE_ID_SUFFIX_XPATH = getXpath("Kopf", "Nachrichtentyp", "code");
static final String PRIMARY_DOCUMENT_NAME_XPATH = getXpath("Primaerdokument", "Dateiname");
@@ -34,7 +36,9 @@ public class XdomeaValueReader {
.processId(readRequiredValue(xdomeaXmlDocument, PROCESS_ID_XPATH))
.messageTypeCode(readRequiredValue(xdomeaXmlDocument, MESSAGE_TYPE_ID_SUFFIX_XPATH))
.authorIdSuffix(readRequiredValue(xdomeaXmlDocument, AUTHOR_ID_SUFFIX_XPATH))
+ .authorIdPrefix(readRequiredValue(xdomeaXmlDocument, AUTHOR_ID_PREFIX_XPATH))
.readerIdSuffix(readRequiredValue(xdomeaXmlDocument, READER_ID_SUFFIX_XPATH))
+ .readerIdPrefix(readRequiredValue(xdomeaXmlDocument, READER_ID_PREFIX_XPATH))
.primaryDocumentNames(readPrimaryDocumentNames(xdomeaXmlDocument))
.build();
}
diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactory.java b/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactory.java
index 9dbcf5e1c3b6d317870ffd93e4c062bea1976af7..74c0c97680258b1c0e6e2fd1df3aaf8ca878af3c 100644
--- a/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactory.java
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactory.java
@@ -33,7 +33,9 @@ public class XdomeaValueReaderFactory {
PROCESS_ID_XPATH,
MESSAGE_TYPE_ID_SUFFIX_XPATH,
AUTHOR_ID_SUFFIX_XPATH,
+ AUTHOR_ID_PREFIX_XPATH,
READER_ID_SUFFIX_XPATH,
+ READER_ID_PREFIX_XPATH,
PRIMARY_DOCUMENT_NAME_XPATH
).collect(Collectors.toMap(
xpath -> xpath,
diff --git a/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaXmlValues.java b/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaXmlValues.java
index 7783474d380204b3ea6b9c9d168db9c847440318..1410fdc5347ecdc109604a56989ced63b703a549 100644
--- a/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaXmlValues.java
+++ b/src/main/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaXmlValues.java
@@ -12,7 +12,9 @@ public record XdomeaXmlValues(
@NotBlank String processId,
@NotBlank String messageTypeCode,
@NotBlank String authorIdSuffix,
+ @NotBlank String authorIdPrefix,
@NotBlank String readerIdSuffix,
+ @NotBlank String readerIdPrefix,
@Valid List<@NotBlank String> primaryDocumentNames
) {
}
diff --git a/src/test/java/de/ozgcloud/xta/client/factory/XdomeaXmlValuesTestFactory.java b/src/test/java/de/ozgcloud/xta/client/factory/XdomeaXmlValuesTestFactory.java
index ca099c7446385e4efee53a903dd6b922e2cd6fe7..a4f402b6f47e37e46f40b7bf533f10519611258e 100644
--- a/src/test/java/de/ozgcloud/xta/client/factory/XdomeaXmlValuesTestFactory.java
+++ b/src/test/java/de/ozgcloud/xta/client/factory/XdomeaXmlValuesTestFactory.java
@@ -9,7 +9,9 @@ public class XdomeaXmlValuesTestFactory {
public static final String PROCESS_ID = "000ProcessId-111";
public static final String SHORT_MESSAGE_TYPE_CODE = "messageTypeCode";
public static final String AUTHOR_ID_SUFFIX = "authorIdSuffix";
+ public static final String AUTHOR_ID_PREFIX = "authorIdPrefix";
public static final String READER_ID_SUFFIX = "readerIdSuffix";
+ public static final String READER_ID_PREFIX = "readerIdPrefix";
public static final List<String> PRIMARY_DOCUMENT_NAMES = List.of("doc.pdf", "doc.xml");
@@ -22,7 +24,9 @@ public class XdomeaXmlValuesTestFactory {
.processId(PROCESS_ID)
.messageTypeCode(SHORT_MESSAGE_TYPE_CODE)
.authorIdSuffix(AUTHOR_ID_SUFFIX)
+ .authorIdPrefix(AUTHOR_ID_PREFIX)
.readerIdSuffix(READER_ID_SUFFIX)
+ .readerIdPrefix(READER_ID_PREFIX)
.primaryDocumentNames(PRIMARY_DOCUMENT_NAMES);
}
}
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorFactoryTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorFactoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..60b10771660b97fb3e29796df425f6a26ebf4872
--- /dev/null
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorFactoryTest.java
@@ -0,0 +1,35 @@
+package de.ozgcloud.xta.client.xdomea;
+
+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;
+import org.mockito.Mock;
+
+import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReader;
+
+class XdomeaMetaDataValidatorFactoryTest {
+
+ @InjectMocks
+ private XdomeaMetaDataValidatorFactory factory;
+
+ @Mock
+ private ZipFileEntryReader zipFileEntryReader;
+
+ @DisplayName("create")
+ @Nested
+ class TestCreate {
+
+ @DisplayName("should return")
+ @Test
+ void shouldReturn() {
+ var result = factory.create();
+
+ assertThat(result).usingRecursiveComparison().isEqualTo(XdomeaMetaDataValidator.builder()
+ .zipFileEntryReader(zipFileEntryReader)
+ .build());
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3251bedc7fb829bd22a35a6d6c6f648c678626c
--- /dev/null
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaMetaDataValidatorTest.java
@@ -0,0 +1,248 @@
+package de.ozgcloud.xta.client.xdomea;
+
+import static de.ozgcloud.xta.client.factory.MessageMetaDataTestFactory.*;
+import static de.ozgcloud.xta.client.factory.XdomeaXmlValuesTestFactory.*;
+import static de.ozgcloud.xta.client.factory.XtaFileTestFactory.*;
+import static de.ozgcloud.xta.client.xdomea.XdomeaMetaDataValidator.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import jakarta.activation.DataHandler;
+
+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.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import de.ozgcloud.xta.client.exception.ClientException;
+import de.ozgcloud.xta.client.factory.XdomeaXmlValuesTestFactory;
+import de.ozgcloud.xta.client.factory.XtaFileTestFactory;
+import de.ozgcloud.xta.client.factory.XtaMessageMetaDataTestFactory;
+import de.ozgcloud.xta.client.model.XtaFile;
+import de.ozgcloud.xta.client.model.XtaMessageMetaData;
+import de.ozgcloud.xta.client.xdomea.mapper.MetadataMapper;
+import de.ozgcloud.xta.client.xdomea.reader.XdomeaXmlValues;
+import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReader;
+import lombok.SneakyThrows;
+
+class XdomeaMetaDataValidatorTest {
+
+ @Spy
+ @InjectMocks
+ private XdomeaMetaDataValidator validator;
+
+ @Mock
+ private ZipFileEntryReader zipFileEntryReader;
+
+ @DisplayName("validate")
+ @Nested
+ class TestValidate {
+
+ private XtaFile xdomeaZipFile;
+
+ private XdomeaXmlValues xdomeaXmlValues;
+
+ private XtaMessageMetaData messageMetadataData;
+
+ @BeforeEach
+ @SneakyThrows
+ void mock() {
+ xdomeaZipFile = XtaFileTestFactory.create();
+ xdomeaXmlValues = XdomeaXmlValuesTestFactory.create();
+ messageMetadataData = XtaMessageMetaDataTestFactory.create();
+ doNothing().when(validator).validateIdentifierPrefixes(any(), any());
+ doNothing().when(validator).validateZipFileName(any(), any(), any());
+ doNothing().when(validator).validatePrimaryDocumentReferences(any(), any());
+ }
+
+ @DisplayName("should verify identifier prefixes")
+ @Test
+ @SneakyThrows
+ void shouldVerifyIdentifierPrefixes() {
+ validate();
+
+ verify(validator).validateIdentifierPrefixes(
+ AUTHOR_ID_PREFIX,
+ READER_ID_PREFIX
+ );
+ }
+
+ @DisplayName("should verify zip file name")
+ @Test
+ @SneakyThrows
+ void shouldVerifyZipFileName() {
+ validate();
+
+ verify(validator).validateZipFileName(
+ XTA_FILE_NAME,
+ PROCESS_ID,
+ MESSAGE_TYPE_CODE
+ );
+ }
+
+ @DisplayName("should verify primary document references")
+ @Test
+ @SneakyThrows
+ void shouldVerifyPrimaryDocumentReferences() {
+ validate();
+
+ verify(validator).validatePrimaryDocumentReferences(
+ xdomeaZipFile,
+ PRIMARY_DOCUMENT_NAMES
+ );
+ }
+
+ @SneakyThrows
+ private void validate() {
+ validator.validate(xdomeaZipFile, xdomeaXmlValues, messageMetadataData);
+ }
+ }
+
+ @DisplayName("validate identifier prefixes")
+ @Nested
+ class TestValidateIdentifierPrefixes {
+
+ @BeforeEach
+ @SneakyThrows
+ void mock() {
+ doNothing().when(validator).validateIdentifierPrefix(any(), any(), any());
+ }
+
+ @DisplayName("should validate author identifier prefix")
+ @Test
+ @SneakyThrows
+ void shouldValidateAuthorIdentifierPrefix() {
+ validator.validateIdentifierPrefixes(AUTHOR_ID_PREFIX, READER_ID_PREFIX);
+
+ verify(validator).validateIdentifierPrefix(
+ AUTHOR_ID_PREFIX,
+ MetadataMapper.AUTHOR_ID_PREFIX,
+ AUTHOR_ID_PREFIX_NAME
+ );
+ }
+
+ @DisplayName("should validate reader identifier prefix")
+ @Test
+ @SneakyThrows
+ void shouldValidateReaderIdentifierPrefix() {
+ validator.validateIdentifierPrefixes(AUTHOR_ID_PREFIX, READER_ID_PREFIX);
+
+ verify(validator).validateIdentifierPrefix(
+ READER_ID_PREFIX,
+ MetadataMapper.READER_ID_PREFIX,
+ READER_ID_PREFIX_NAME
+ );
+ }
+ }
+
+ @DisplayName("validate identifier prefix")
+ @Nested
+ class TestValidateIdentifierPrefix {
+
+ private static final String EXPECTED_PREFIX = "prefix";
+ private static final String PREFIX_NAME = "prefixName";
+
+ @DisplayName("should normalize prefix")
+ @ParameterizedTest
+ @ValueSource(strings = {
+ "prefix:",
+ "prefix",
+ })
+ @SneakyThrows
+ void shouldNormalizePrefix(String prefix) {
+ validator.validateIdentifierPrefix(prefix, EXPECTED_PREFIX, PREFIX_NAME);
+ }
+
+ @DisplayName("should throw client exception for wrong prefix")
+ @ParameterizedTest
+ @ValueSource(strings = {
+ "prefi",
+ "prefix::",
+ "prefix$:",
+ "prefix$",
+ })
+ void shouldThrowClientExceptionForWrongPrefix(String prefix) {
+ assertThatThrownBy(() -> validator.validateIdentifierPrefix(prefix, EXPECTED_PREFIX, PREFIX_NAME))
+ .isInstanceOf(ClientException.class)
+ .hasMessageContaining(PREFIX_NAME);
+ }
+
+ }
+
+ @DisplayName("validate zip file name")
+ @Nested
+ class TestValidateZipFileName {
+
+ private static final String PROCESS_ID = "processId";
+ private static final String MESSAGE_TYPE_CODE = "messageTypeCode";
+ private static final String VALID_ZIP_FILE_NAME = "processId_messageTypeCode.zip";
+
+ @DisplayName("should not throw exception for valid zip file name")
+ @Test
+ void shouldNotThrowExceptionForValidZipFileName() {
+ assertThatCode(() -> validator.validateZipFileName(VALID_ZIP_FILE_NAME, PROCESS_ID, MESSAGE_TYPE_CODE))
+ .doesNotThrowAnyException();
+ }
+
+ @DisplayName("should throw client exception for wrong zip file name")
+ @ParameterizedTest
+ @ValueSource(strings = {
+ "$processId_messageTypeCode.zip",
+ "processId_me$ssageTypeCode.zip",
+ "processId_messageTypeCode.zip$",
+ })
+ void shouldThrowClientExceptionForWrongZipFileName(String wrongZipFileName) {
+ assertThatThrownBy(() -> validator.validateZipFileName(wrongZipFileName, PROCESS_ID, MESSAGE_TYPE_CODE))
+ .isInstanceOf(ClientException.class);
+ }
+
+ }
+
+ @DisplayName("validate primary document references")
+ @Nested
+ class TestValidatePrimaryDocumentReferences {
+
+ private static final List<String> VALID_ZIP_ENTRY_NAMES = List.of("doc.pdf", "doc.xml", "other.doc");
+ private static final List<String> INVALID_ZIP_ENTRY_NAMES = List.of("doc.pdf");
+
+ @Mock
+ private XtaFile xdomeaZipFile;
+
+ @Mock
+ private DataHandler contentDataHandler;
+
+ @BeforeEach
+ @SneakyThrows
+ void mock() {
+ when(xdomeaZipFile.content()).thenReturn(contentDataHandler);
+
+ }
+
+ @DisplayName("should not throw exception for valid primary document references")
+ @Test
+ @SneakyThrows
+ void shouldNotThrowExceptionForValidPrimaryDocumentReferences() {
+ when(zipFileEntryReader.getEntryNames(contentDataHandler)).thenReturn(VALID_ZIP_ENTRY_NAMES);
+
+ validator.validatePrimaryDocumentReferences(xdomeaZipFile, PRIMARY_DOCUMENT_NAMES);
+ }
+
+ @DisplayName("should throw client exception for missing primary document references")
+ @Test
+ @SneakyThrows
+ void shouldThrowClientExceptionForMissingPrimaryDocumentReferences() {
+ when(zipFileEntryReader.getEntryNames(contentDataHandler)).thenReturn(INVALID_ZIP_ENTRY_NAMES);
+
+ assertThatThrownBy(() -> validator.validatePrimaryDocumentReferences(xdomeaZipFile, PRIMARY_DOCUMENT_NAMES))
+ .isInstanceOf(ClientException.class);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactoryTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactoryTest.java
index 578ea24b61a8b077455ee9693ca0ba805e870bce..f8cf3fff6982ae1170b4ace41edb6cb193c43f52 100644
--- a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactoryTest.java
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorFactoryTest.java
@@ -38,7 +38,6 @@ import de.ozgcloud.xta.client.xdomea.mapper.MetadataMapper;
import de.ozgcloud.xta.client.xdomea.reader.XdomeaValueReader;
import de.ozgcloud.xta.client.xdomea.reader.XdomeaValueReaderFactory;
import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReader;
-import de.ozgcloud.xta.client.xdomea.reader.ZipFileEntryReaderFactory;
import lombok.SneakyThrows;
class XdomeaXtaMessageCreatorFactoryTest {
@@ -51,7 +50,7 @@ class XdomeaXtaMessageCreatorFactoryTest {
private XdomeaValueReaderFactory xdomeaValueReaderFactory;
@Mock
- private ZipFileEntryReaderFactory zipFileEntryReaderFactory;
+ private ZipFileEntryReader zipFileEntryReader;
@Mock
private DocumentBuilderFactory documentBuilderFactory;
@@ -59,6 +58,9 @@ class XdomeaXtaMessageCreatorFactoryTest {
@Mock
private MetadataMapper metadataMapper;
+ @Mock
+ private XdomeaMetaDataValidatorFactory xdomeaMetaDataValidatorFactory;
+
@Mock
private SchemaFactory schemaFactory;
@@ -79,10 +81,10 @@ class XdomeaXtaMessageCreatorFactoryTest {
private DocumentBuilder documentBuilder;
@Mock
- private ZipFileEntryReader zipFileEntryReader;
+ private ParserConfigurationException parserConfigurationException;
@Mock
- private ParserConfigurationException parserConfigurationException;
+ private XdomeaMetaDataValidator metaDataValidator;
@Mock
private Schema schema;
@@ -92,7 +94,7 @@ class XdomeaXtaMessageCreatorFactoryTest {
when(documentBuilderFactory.newDocumentBuilder()).thenReturn(documentBuilder);
doReturn(schema).when(factory).createSchema();
when(xdomeaValueReaderFactory.create()).thenReturn(xdomeaValueReader);
- when(zipFileEntryReaderFactory.create()).thenReturn(zipFileEntryReader);
+ when(xdomeaMetaDataValidatorFactory.create()).thenReturn(metaDataValidator);
}
@DisplayName("should return")
@@ -107,6 +109,7 @@ class XdomeaXtaMessageCreatorFactoryTest {
.xdomeaValueReader(xdomeaValueReader)
.zipFileEntryReader(zipFileEntryReader)
.metadataMapper(metadataMapper)
+ .metaDataValidator(metaDataValidator)
.build());
}
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorITCase.java b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorITCase.java
index 732c1ac40144339671fe5a8bd2ac9246e5e925ff..7edc2d0d55e829da831947dbc4a73e7793c2c17d 100644
--- a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorITCase.java
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorITCase.java
@@ -1,6 +1,6 @@
package de.ozgcloud.xta.client.xdomea;
-import static de.ozgcloud.xta.client.factory.MessageMetaDataTestFactory.*;
+import static de.ozgcloud.xta.client.extension.XtaServerSetupExtensionTestUtil.*;
import static de.ozgcloud.xta.client.xdomea.mapper.MetadataMapper.*;
import static org.assertj.core.api.Assertions.*;
@@ -38,8 +38,7 @@ class XdomeaXtaMessageCreatorITCase {
var xtaMessage = creator.createMessage(xdomeaZipFile);
- var readerIdentifierSuffix = getIdentifierValueSuffix(xtaMessage.metaData().readerIdentifier().value());
- assertThat(readerIdentifierSuffix).isEqualTo(getIdentifierValueSuffix(READER_IDENTIFIER.value()));
+ assertThat(xtaMessage.metaData().readerIdentifier().value()).isEqualTo(READER_CLIENT_IDENTIFIER1.value());
}
@DisplayName("should use author")
@@ -51,12 +50,7 @@ class XdomeaXtaMessageCreatorITCase {
var xtaMessage = creator.createMessage(xdomeaZipFile);
- var authorIdentifierSuffix = getIdentifierValueSuffix(xtaMessage.metaData().authorIdentifier().value());
- assertThat(authorIdentifierSuffix).isEqualTo(getIdentifierValueSuffix(AUTHOR_IDENTIFIER.value()));
- }
-
- private String getIdentifierValueSuffix(String identifierValue) {
- return identifierValue.substring(identifierValue.indexOf(":") + 1);
+ assertThat(xtaMessage.metaData().authorIdentifier().value()).isEqualTo(AUTHOR_CLIENT_IDENTIFIER.value());
}
@DisplayName("should use message type code for 0201")
@@ -127,8 +121,8 @@ class XdomeaXtaMessageCreatorITCase {
private XtaMessageExampleLoader.MessageExampleConfig.MessageExampleConfigBuilder createExampleConfigBuilder() {
return XtaMessageExampleLoader.MessageExampleConfig.builder()
- .author(AUTHOR_IDENTIFIER)
- .reader(READER_IDENTIFIER);
+ .author(AUTHOR_CLIENT_IDENTIFIER)
+ .reader(READER_CLIENT_IDENTIFIER1);
}
private XtaFile loadMessageFileWithPatch(String messageLabel, String patchLabel) {
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorTest.java
index 134454daa3c437f6180b664e6b416598ee8ce594..6ffa37b6177f2022c068f847707a02c5d8e36d3f 100644
--- a/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorTest.java
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/XdomeaXtaMessageCreatorTest.java
@@ -1,13 +1,9 @@
package de.ozgcloud.xta.client.xdomea;
-import static de.ozgcloud.xta.client.factory.MessageMetaDataTestFactory.*;
-import static de.ozgcloud.xta.client.factory.XdomeaXmlValuesTestFactory.*;
-import static de.ozgcloud.xta.client.factory.XtaFileTestFactory.*;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.io.InputStream;
-import java.util.List;
import java.util.function.Function;
import javax.xml.parsers.DocumentBuilder;
@@ -18,8 +14,6 @@ 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.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
@@ -57,6 +51,9 @@ class XdomeaXtaMessageCreatorTest {
@Mock
private ZipFileEntryReader zipFileEntryReader;
+ @Mock
+ private XdomeaMetaDataValidator metaDataValidator;
+
@DisplayName("create message")
@Nested
class TestCreateMessage {
@@ -136,40 +133,21 @@ class XdomeaXtaMessageCreatorTest {
assertThat(result).isEqualTo(metaData);
}
- @DisplayName("should verify zip file name")
- @Test
- @SneakyThrows
- void shouldVerifyZipFileName() {
- mockValidMetadata();
-
- creator.deriveValidMetaData(xdomeaZipFile);
-
- verify(creator).validateZipFileName(
- XTA_FILE_NAME,
- PROCESS_ID,
- MESSAGE_TYPE_CODE
- );
- }
-
- @DisplayName("should verify primary document references")
+ @DisplayName("should validate")
@Test
@SneakyThrows
- void shouldVerifyPrimaryDocumentReferences() {
+ void shouldValidate() {
mockValidMetadata();
creator.deriveValidMetaData(xdomeaZipFile);
- verify(creator).validatePrimaryDocumentReferences(
- xdomeaZipFile,
- PRIMARY_DOCUMENT_NAMES
- );
+ verify(metaDataValidator).validate(xdomeaZipFile, xdomeaXmlValues, metaData);
}
@SneakyThrows
private void mockValidMetadata() {
doReturn(metaData).when(metadataMapper).mapXtaMessageMetadata(xdomeaXmlValues);
- doNothing().when(creator).validateZipFileName(any(), any(), any());
- doNothing().when(creator).validatePrimaryDocumentReferences(any(), any());
+ doNothing().when(metaDataValidator).validate(xdomeaZipFile, xdomeaXmlValues, metaData);
}
@DisplayName("should throw client exception")
@@ -264,73 +242,4 @@ class XdomeaXtaMessageCreatorTest {
}
}
- @DisplayName("validate zip file name")
- @Nested
- class TestValidateZipFileName {
-
- private static final String PROCESS_ID = "processId";
- private static final String MESSAGE_TYPE_CODE = "messageTypeCode";
- private static final String VALID_ZIP_FILE_NAME = "processId_messageTypeCode.zip";
-
- @DisplayName("should not throw exception for valid zip file name")
- @Test
- void shouldNotThrowExceptionForValidZipFileName() {
- assertThatCode(() -> creator.validateZipFileName(VALID_ZIP_FILE_NAME, PROCESS_ID, MESSAGE_TYPE_CODE))
- .doesNotThrowAnyException();
- }
-
- @DisplayName("should throw client exception for wrong zip file name")
- @ParameterizedTest
- @ValueSource(strings = {
- "$processId_messageTypeCode.zip",
- "processId_me$ssageTypeCode.zip",
- "processId_messageTypeCode.zip$",
- })
- void shouldThrowClientExceptionForWrongZipFileName(String wrongZipFileName) {
- assertThatThrownBy(() -> creator.validateZipFileName(wrongZipFileName, PROCESS_ID, MESSAGE_TYPE_CODE))
- .isInstanceOf(ClientException.class);
- }
-
- }
-
- @DisplayName("validate primary document references")
- @Nested
- class TestValidatePrimaryDocumentReferences {
-
- private static final List<String> VALID_ZIP_ENTRY_NAMES = List.of("doc.pdf", "doc.xml", "other.doc");
- private static final List<String> INVALID_ZIP_ENTRY_NAMES = List.of("doc.pdf");
-
- @Mock
- private XtaFile xdomeaZipFile;
-
- @Mock
- private DataHandler contentDataHandler;
-
- @BeforeEach
- @SneakyThrows
- void mock() {
- when(xdomeaZipFile.content()).thenReturn(contentDataHandler);
-
- }
-
- @DisplayName("should not throw exception for valid primary document references")
- @Test
- @SneakyThrows
- void shouldNotThrowExceptionForValidPrimaryDocumentReferences() {
- when(zipFileEntryReader.getEntryNames(contentDataHandler)).thenReturn(VALID_ZIP_ENTRY_NAMES);
-
- creator.validatePrimaryDocumentReferences(xdomeaZipFile, PRIMARY_DOCUMENT_NAMES);
- }
-
- @DisplayName("should throw client exception for missing primary document references")
- @Test
- @SneakyThrows
- void shouldThrowClientExceptionForMissingPrimaryDocumentReferences() {
- when(zipFileEntryReader.getEntryNames(contentDataHandler)).thenReturn(INVALID_ZIP_ENTRY_NAMES);
-
- assertThatThrownBy(() -> creator.validatePrimaryDocumentReferences(xdomeaZipFile, PRIMARY_DOCUMENT_NAMES))
- .isInstanceOf(ClientException.class);
- }
- }
-
}
\ No newline at end of file
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/mapper/MetadataMapperTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/mapper/MetadataMapperTest.java
index 25e7a8faa0af6c9591e61d346aaa08c550435092..46ed9f9fbfd4c6e95439562023ea9c723dc7e1d5 100644
--- a/src/test/java/de/ozgcloud/xta/client/xdomea/mapper/MetadataMapperTest.java
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/mapper/MetadataMapperTest.java
@@ -14,7 +14,6 @@ import org.mapstruct.factory.Mappers;
import de.ozgcloud.common.errorhandling.TechnicalException;
import de.ozgcloud.xta.client.factory.XdomeaXmlValuesTestFactory;
import de.ozgcloud.xta.client.model.XtaMessageMetaData;
-import de.ozgcloud.xta.client.xdomea.reader.XdomeaXmlValues;
class MetadataMapperTest {
@@ -105,7 +104,7 @@ class MetadataMapperTest {
void shouldMapAuthorIdentifierValue(String code) {
var metadata = doMapping(code);
- assertThat(metadata.authorIdentifier().value()).isEqualTo(AUTHOR_ID_PREFIX + ":" + AUTHOR_ID_SUFFIX);
+ assertThat(metadata.authorIdentifier().value()).isEqualTo(MetadataMapper.AUTHOR_ID_PREFIX + ":" + AUTHOR_ID_SUFFIX);
}
@DisplayName("should map author identifier category")
@@ -123,7 +122,7 @@ class MetadataMapperTest {
void shouldMapReaderIdentifierValue(String code) {
var metadata = doMapping(code);
- assertThat(metadata.readerIdentifier().value()).isEqualTo(READER_ID_PREFIX + ":" + READER_ID_SUFFIX);
+ assertThat(metadata.readerIdentifier().value()).isEqualTo(MetadataMapper.READER_ID_PREFIX + ":" + READER_ID_SUFFIX);
}
@DisplayName("should map reader identifier category")
@@ -135,8 +134,6 @@ class MetadataMapperTest {
assertThat(metadata.readerIdentifier().category()).isEqualTo(READER_ID_CATEGORY);
}
- private final XdomeaXmlValues xdomeaXmlValues = XdomeaXmlValuesTestFactory.create();
-
@DisplayName("should throw technical exception with unknown message type code")
@Test
void shouldThrowTechnicalExceptionWithUnknownMessageTypeCode() {
@@ -150,10 +147,6 @@ class MetadataMapperTest {
.build());
}
-
-
-
-
}
}
\ No newline at end of file
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactoryTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactoryTest.java
index e2fd3afd7e8daf8e5c006b135741a9f77515b190..4acd368a45533018285fee40eed16cba77dd36f9 100644
--- a/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactoryTest.java
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderFactoryTest.java
@@ -41,9 +41,15 @@ class XdomeaValueReaderFactoryTest {
@Mock
XmlValueReader authorIdReader;
+ @Mock
+ XmlValueReader authorIdPrefixReader;
+
@Mock
XmlValueReader readerIdReader;
+ @Mock
+ XmlValueReader readerIdPrefixReader;
+
@Mock
XmlValueReader primaryDocumentNameReader;
@@ -54,7 +60,9 @@ class XdomeaValueReaderFactoryTest {
doReturn(procesIdReader).when(factory).createXmlValueReader(PROCESS_ID_XPATH);
doReturn(messageTypeReader).when(factory).createXmlValueReader(MESSAGE_TYPE_ID_SUFFIX_XPATH);
doReturn(authorIdReader).when(factory).createXmlValueReader(AUTHOR_ID_SUFFIX_XPATH);
+ doReturn(authorIdPrefixReader).when(factory).createXmlValueReader(AUTHOR_ID_PREFIX_XPATH);
doReturn(readerIdReader).when(factory).createXmlValueReader(READER_ID_SUFFIX_XPATH);
+ doReturn(readerIdPrefixReader).when(factory).createXmlValueReader(READER_ID_PREFIX_XPATH);
doReturn(primaryDocumentNameReader).when(factory).createXmlValueReader(PRIMARY_DOCUMENT_NAME_XPATH);
var reader = factory.create();
@@ -64,7 +72,9 @@ class XdomeaValueReaderFactoryTest {
PROCESS_ID_XPATH, procesIdReader,
MESSAGE_TYPE_ID_SUFFIX_XPATH, messageTypeReader,
AUTHOR_ID_SUFFIX_XPATH, authorIdReader,
+ AUTHOR_ID_PREFIX_XPATH, authorIdPrefixReader,
READER_ID_SUFFIX_XPATH, readerIdReader,
+ READER_ID_PREFIX_XPATH, readerIdPrefixReader,
PRIMARY_DOCUMENT_NAME_XPATH, primaryDocumentNameReader
)).build());
}
diff --git a/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderTest.java b/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderTest.java
index 5b47cc40f94490514007355bef9e10c618a38840..9c72e7ab2ab52438c42b923abbc78b4b519d335e 100644
--- a/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderTest.java
+++ b/src/test/java/de/ozgcloud/xta/client/xdomea/reader/XdomeaValueReaderTest.java
@@ -37,7 +37,9 @@ class XdomeaValueReaderTest {
private static final String PROCESS_ID = "process id";
private static final String MESSAGE_TYPE_CODE = "message type code";
private static final String AUTHOR_ID_SUFFIX = "author id suffix";
+ private static final String AUTHOR_ID_PREFIX = "author id prefix";
private static final String READER_ID_SUFFIX = "reader id suffix";
+ private static final String READER_ID_PREFIX = "reader id prefix";
private static final List<String> PRIMARY_DOCUMENT_NAMES = List.of("primary document name");
@Mock
@@ -49,7 +51,9 @@ class XdomeaValueReaderTest {
doReturn(PROCESS_ID).when(xdomeaValueReader).readRequiredValue(xdomeaXmlDocument, XdomeaValueReader.PROCESS_ID_XPATH);
doReturn(MESSAGE_TYPE_CODE).when(xdomeaValueReader).readRequiredValue(xdomeaXmlDocument, XdomeaValueReader.MESSAGE_TYPE_ID_SUFFIX_XPATH);
doReturn(AUTHOR_ID_SUFFIX).when(xdomeaValueReader).readRequiredValue(xdomeaXmlDocument, XdomeaValueReader.AUTHOR_ID_SUFFIX_XPATH);
+ doReturn(AUTHOR_ID_PREFIX).when(xdomeaValueReader).readRequiredValue(xdomeaXmlDocument, XdomeaValueReader.AUTHOR_ID_PREFIX_XPATH);
doReturn(READER_ID_SUFFIX).when(xdomeaValueReader).readRequiredValue(xdomeaXmlDocument, XdomeaValueReader.READER_ID_SUFFIX_XPATH);
+ doReturn(READER_ID_PREFIX).when(xdomeaValueReader).readRequiredValue(xdomeaXmlDocument, XdomeaValueReader.READER_ID_PREFIX_XPATH);
doReturn(PRIMARY_DOCUMENT_NAMES).when(xdomeaValueReader).readPrimaryDocumentNames(xdomeaXmlDocument);
}
@@ -77,6 +81,14 @@ class XdomeaValueReaderTest {
assertThat(result.authorIdSuffix()).isEqualTo(AUTHOR_ID_SUFFIX);
}
+ @DisplayName("should return author id prefix")
+ @Test
+ void shouldReturnAuthorIdPrefix() {
+ var result = readValues();
+
+ assertThat(result.authorIdPrefix()).isEqualTo(AUTHOR_ID_PREFIX);
+ }
+
@DisplayName("should return reader id suffix")
@Test
void shouldReturnReaderIdSuffix() {
@@ -85,6 +97,14 @@ class XdomeaValueReaderTest {
assertThat(result.readerIdSuffix()).isEqualTo(READER_ID_SUFFIX);
}
+ @DisplayName("should return reader id prefix")
+ @Test
+ void shouldReturnReaderIdPrefix() {
+ var result = readValues();
+
+ assertThat(result.readerIdPrefix()).isEqualTo(READER_ID_PREFIX);
+ }
+
@DisplayName("should return primary document names")
@Test
void shouldReturnPrimaryDocumentNames() {