OZG-6239 Filter getStatusList result by readerIdentifier

src/main/java/de/ozgcloud/xta/test/app/data/XtaMessageRepository.java

@@ -7,6 +7,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Stream;
 
 import org.springframework.stereotype.Component;
 
@@ -47,13 +48,18 @@ public class XtaMessageRepository {
 		}
 	}
 
-	public List<XtaMessage> findAllLimitedTo(int maxListItems) {
-		return messages.values().stream()
+	public List<XtaMessage> findByReaderIdentifierValueLimitedTo(String readerIdentifierValue, int maxListItems) {
+		return findByReaderIdentifierValue(readerIdentifierValue)
 				.limit(maxListItems)
 				.toList();
 	}
 
-	public BigInteger count() {
-		return BigInteger.valueOf(messages.size());
+	public BigInteger countByReaderIdentifierValue(String readerIdentifierValue) {
+		return BigInteger.valueOf(findByReaderIdentifierValue(readerIdentifierValue).count());
+	}
+
+	Stream<XtaMessage> findByReaderIdentifierValue(String readerIdentifierValue) {
+		return messages.values().stream()
+				.filter(m -> m.metaData().readerIdentifier().value().equals(readerIdentifierValue));
 	}
 }

src/main/java/de/ozgcloud/xta/test/app/mapper/RequestMapper.java

 package de.ozgcloud.xta.test.app.mapper;
 
 import de.ozgcloud.xta.test.app.exception.TechnicalException;
+import de.ozgcloud.xta.test.app.model.Identifier;
 import de.ozgcloud.xta.test.app.model.XtaFile;
 import de.ozgcloud.xta.test.app.model.XtaMessage;
 import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
+import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListingRequest;
 import genv3.de.xoev.transport.xta.x211.ContentType;
 import genv3.de.xoev.transport.xta.x211.GenericContentContainer;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxFetchRequest;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxStatusListRequestType;
 import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
+import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
+import genv3.eu.osci.ws.x2014.x10.transport.PartyType;
 import genv3.eu.osci.ws.x2014.x10.transport.QualifierType;
 import jakarta.activation.DataHandler;
+
+import org.mapstruct.Condition;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
+import org.mapstruct.Named;
 import org.mapstruct.ReportingPolicy;
 
 import java.io.File;
@@ -30,7 +37,10 @@ public interface RequestMapper {
 	XtaMessage mapXtaMessageFromGenericContentContainer(GenericContentContainer genericContainer, MessageMetaData messageMetaData);
 
 	@Mapping(target = "service", source = "qualifier.service")
-	@Mapping(target = "businessScenario", source = "qualifier.businessScenario")
+	@Mapping(target = "businessScenarioCode", source = "qualifier.businessScenario", qualifiedByName = "mapBusinessScenarioCode")
+	@Mapping(target = "businessScenarioName", source = "qualifier.businessScenario.defined.name")
+	@Mapping(target = "businessScenarioListUri", source = "qualifier.businessScenario.defined.listURI")
+	@Mapping(target = "businessScenarioListVersionId", source = "qualifier.businessScenario.defined.listVersionID")
 	@Mapping(target = "messageTypeCode", source = "qualifier.messageType.code")
 	@Mapping(target = "messageTypePayloadSchema", source = "qualifier.messageType.payloadSchema")
 	@Mapping(target = "messageId", source = "msgIdentification.messageID.value")
@@ -39,23 +49,12 @@ public interface RequestMapper {
 	@Mapping(target = "messageSize", source = "msgSize")
 	XtaMessageMetaData mapXtaMessageMetaData(MessageMetaData messageMetaData);
 
-	default XtaMessageMetaData.BusinessScenario mapBusinessScenarioFromQualifierTypeBusinessScenario(QualifierType.BusinessScenario businessScenario){
-		if (businessScenario.getDefined() != null && businessScenario.getDefined().getCode() != null) {
-			var definedKeyCode = businessScenario.getDefined();
-			return new XtaMessageMetaData.BusinessScenario(
-					definedKeyCode.getCode(),
-					definedKeyCode.getName(),
-					definedKeyCode.getListURI(),
-					definedKeyCode.getListVersionID(),
-					true);
-		}
-		else {
-			String businessScenarioCode = businessScenario.getUndefined() == null ? "" : businessScenario.getUndefined();
-			return new XtaMessageMetaData.BusinessScenario(
-					businessScenarioCode, null, null, null, false);
-		}
+	@Named("mapBusinessScenarioCode")
+	default String mapBusinessScenarioCode(QualifierType.BusinessScenario businessScenario){
+		return businessScenario.getDefined() != null ? businessScenario.getDefined().getCode() : businessScenario.getUndefined();
 	}
 
+
 	@Mapping(target = "file", source = "value")
 	@Mapping(target = "name", source = "filename")
 	@Mapping(target = "language", source = "lang")
@@ -92,4 +91,8 @@ public interface RequestMapper {
 		}
 		return maxListItems;
 	}
+
+	@Mapping(target = "clientIdentifierValue", source = "clientIdentifier.identifier.value")
+	@Mapping(target = "maxListItems", source = "fetchRequest.maxListItems")
+	XtaMessageMetaDataListingRequest mapMessageMetaDataListingRequest(MsgBoxStatusListRequestType fetchRequest, PartyType clientIdentifier);
 }

src/main/java/de/ozgcloud/xta/test/app/mapper/ResponseMapper.java

@@ -8,6 +8,7 @@ import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
 import genv3.de.xoev.transport.xta.x211.ContentType;
 import genv3.de.xoev.transport.xta.x211.GenericContentContainer;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxResponseType;
+import genv3.eu.osci.ws.x2008.x05.transport.MsgStatusListType;
 import genv3.eu.osci.ws.x2014.x10.transport.KeyCodeType;
 import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
 import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
@@ -19,6 +20,7 @@ import jakarta.activation.FileDataSource;
 import org.mapstruct.Condition;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
+import org.mapstruct.Named;
 import org.mapstruct.ReportingPolicy;
 import org.mapstruct.SourcePropertyName;
 import org.mapstruct.TargetPropertyName;
@@ -35,9 +37,11 @@ public interface ResponseMapper {
 	String IDENTIFIER_TYPE = "xoev";
 	String MESSAGE_TYPE_LIST_URI = "urn:de:payloadSchema:elementName";
 	String MESSAGE_TYPE_LIST_VERSION_ID = "1.0";
+	String REQUEST_ID = "1";
+	String NO_MESSAGES_REASON = "Keine Nachrichten gefunden.";
 
 	@Mapping(target = "qualifier.service", source = "service")
-	@Mapping(target = "qualifier.businessScenario", source = "businessScenario")
+	@Mapping(target = "qualifier.businessScenario", source = ".", qualifiedByName = "mapBusinessScenario")
 	@Mapping(target = "qualifier.messageType", source = ".")
 	@Mapping(target = "msgIdentification.messageID.value", source = "messageId")
 	@Mapping(target = "originators.author.identifier", source = "authorIdentifier")
@@ -48,22 +52,27 @@ public interface ResponseMapper {
 	@Mapping(target = "messageProperties", ignore = true)
 	MessageMetaData mapMessageMetaDataFromXtaMessageMetaData(XtaMessageMetaData xtaMessageMetaData);
 
-	default QualifierType.BusinessScenario mapQualifierBusinessScenarioFromBusinessScenario(XtaMessageMetaData.BusinessScenario businessScenario) {
-		var qualifierBusinessScenario = new QualifierType.BusinessScenario();
-		if (businessScenario.isDefinedCode()) {
-			var definedKeyCode = new KeyCodeType();
-			definedKeyCode.setCode(businessScenario.businessScenarioCode());
-			definedKeyCode.setName(businessScenario.name());
-			definedKeyCode.setListURI(businessScenario.listURI());
-			definedKeyCode.setListVersionID(businessScenario.listVersionID());
-			qualifierBusinessScenario.setDefined(definedKeyCode);
-		} else {
-			qualifierBusinessScenario.setDefined(null);
-			qualifierBusinessScenario.setUndefined(businessScenario.businessScenarioCode());
-		}
-		return qualifierBusinessScenario;
+	@Named("mapBusinessScenario")
+	default QualifierType.BusinessScenario mapBusinessScenario(XtaMessageMetaData xtaMessageMetaData) {
+		return xtaMessageMetaData.businessScenarioListUri() != null
+				? mapDefinedBusinessScenario(xtaMessageMetaData)
+				: mapUndefinedBusinessScenario(xtaMessageMetaData);
 	}
 
+	@Mapping(target = "defined", expression = "java(null)")
+	@Mapping(target = "undefined", source = "businessScenarioCode")
+	QualifierType.BusinessScenario mapUndefinedBusinessScenario(XtaMessageMetaData xtaMessageMetaData);
+
+	@Mapping(target = "defined", source = ".")
+	@Mapping(target = "undefined", expression = "java(null)")
+	QualifierType.BusinessScenario mapDefinedBusinessScenario(XtaMessageMetaData xtaMessageMetaData);
+
+	@Mapping(target = "code", source = "businessScenarioCode")
+	@Mapping(target = "name", source = "businessScenarioName")
+	@Mapping(target = "listURI", source = "businessScenarioListUri")
+	@Mapping(target = "listVersionID", source = "businessScenarioListVersionId")
+	KeyCodeType mapKeyCodeType(XtaMessageMetaData xtaMessageMetaData);
+
 	@Mapping(target = "code", source = "messageTypeCode")
 	@Mapping(target = "name", ignore = true)
 	@Mapping(target = "payloadSchema", source = "messageTypePayloadSchema")
@@ -72,7 +81,7 @@ public interface ResponseMapper {
 	QualifierType.MessageType mapMessageTypeQualifierType(XtaMessageMetaData xtaMessageMetaData);
 
 	@Mapping(target = "type", constant = IDENTIFIER_TYPE)
-	PartyIdentifierType mapPartyIdentifierTypeFromIdentifier(Identifier value);
+	PartyIdentifierType mapPartyIdentifierType(Identifier value);
 
 	@Mapping(target = "encryptedData", expression = "java(null)")
 	@Mapping(target = "contentContainer.message", source = "messageFile")
@@ -95,9 +104,16 @@ public interface ResponseMapper {
 	MsgBoxResponseType mapMsgBoxResponseTypeFromRequestID(String requestId);
 
 	@Mapping(target = "itemsPending", source = "pendingMessageCount")
-	@Mapping(target = "msgBoxRequestID", source = "requestId")
-	@Mapping(target = "noMessageAvailable", source = "messages")
-	MsgBoxResponseType mapMsgBoxResponseTypeFromXtaMessageMetaDataListing(XtaMessageMetaDataListing xtaMessageMetaDataListing);
+	@Mapping(target = "msgBoxRequestID", constant = REQUEST_ID)
+	@Mapping(target = "noMessageAvailable", source = "messages", qualifiedByName = "mapNoMessageAvailableReason")
+	MsgBoxResponseType mapMsgBoxResponseType(XtaMessageMetaDataListing listing);
+
+	@Named("mapNoMessageAvailableReason")
+	default MsgBoxResponseType.NoMessageAvailable mapNoMessageAvailableReason(List<XtaMessageMetaData> messages) {
+		return messages.isEmpty() ? createNoMessageAvailableWithReason(NO_MESSAGES_REASON) : null;
+	}
+
+	MsgBoxResponseType.NoMessageAvailable createNoMessageAvailableWithReason(String reason);
 
 	@Condition
 	default boolean pendingMessagesCountIsNotZero(BigInteger pendingMessageCount, @TargetPropertyName String targetPropertyName,
@@ -109,13 +125,12 @@ public interface ResponseMapper {
 		return true;
 	}
 
-	default MsgBoxResponseType.NoMessageAvailable mapNoMessageAvailableFromXtaMessageMetaDataListing(
-			List<XtaMessageMetaData> messages) {
-		if (messages.isEmpty()) {
-			var noMessagesAvailable = new MsgBoxResponseType.NoMessageAvailable();
-			noMessagesAvailable.setReason("NoMatch: No message fits the criteria from the message-selector.");
-			return noMessagesAvailable;
-		} else
-			return null;
-	}
+	@Mapping(target = "messageMetaData", source = "messages")
+	@Mapping(target = "msgAttributes", ignore = true)
+	MsgStatusListType mapMsgStatusListType(XtaMessageMetaDataListing listing);
+
+	@Mapping(target = "msgBoxRequestID", constant = REQUEST_ID)
+	@Mapping(target = "itemsPending", ignore = true)
+	@Mapping(target = "noMessageAvailable.reason", source = "errorString")
+	MsgBoxResponseType mapMsgBoxResponseTypeError(String errorString);
 }

src/main/java/de/ozgcloud/xta/test/app/model/XtaMessageMetaData.java

@@ -2,6 +2,7 @@ package de.ozgcloud.xta.test.app.model;
 
 import java.math.BigInteger;
 
+import jakarta.annotation.Nullable;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
@@ -12,7 +13,10 @@ import lombok.Builder;
 @Builder(toBuilder = true)
 public record XtaMessageMetaData(
 		@NotBlank String service,
-		@NotNull BusinessScenario businessScenario,
+		@NotNull @NotBlank String businessScenarioCode,
+		@Nullable String businessScenarioName,
+		@Nullable String businessScenarioListUri,
+		@Nullable String businessScenarioListVersionId,
 		@NotBlank String messageTypeCode,
 		@NotBlank String messageTypePayloadSchema,
 		@NotBlank String messageId,
@@ -20,12 +24,4 @@ public record XtaMessageMetaData(
 		@NotNull @Valid Identifier readerIdentifier,
 		@PositiveOrZero BigInteger messageSize
 ) {
-	public record BusinessScenario(
-			@NotBlank String businessScenarioCode,
-			String name,
-			String listURI,
-			String listVersionID,
-			boolean isDefinedCode
-	) {
-	}
 }

src/main/java/de/ozgcloud/xta/test/app/model/XtaMessageMetaDataListing.java

@@ -12,7 +12,6 @@ import lombok.Builder;
 
 @Builder
 public record XtaMessageMetaDataListing(
-		@NotBlank String requestId,
 		@NotNull @PositiveOrZero BigInteger pendingMessageCount,
 		@NotNull @Valid List<XtaMessageMetaData> messages
 ) {

src/main/java/de/ozgcloud/xta/test/app/model/XtaMessageMetaDataListingRequest.java

+package de.ozgcloud.xta.test.app.model;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Positive;
+
+import lombok.Builder;
+
+@Builder
+public record XtaMessageMetaDataListingRequest(
+		@NotBlank String clientIdentifierValue,
+		@Positive int maxListItems
+) {
+}

src/main/java/de/ozgcloud/xta/test/app/server/MsgBoxPortImpl.java

@@ -9,7 +9,6 @@ import org.apache.cxf.ws.addressing.AttributedURIType;
 import org.springframework.stereotype.Component;
 
 import de.ozgcloud.xta.test.app.model.XtaMessage;
-import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
 import de.ozgcloud.xta.test.app.service.ParameterValidatorService;
 import de.ozgcloud.xta.test.app.mapper.RequestMapper;
 import de.ozgcloud.xta.test.app.mapper.ResponseMapper;
@@ -21,11 +20,9 @@ import genv3.de.xoev.transport.xta.x211.MsgBoxPortType;
 import genv3.de.xoev.transport.xta.x211.PermissionDeniedException;
 import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxFetchRequest;
-import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxResponseType;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxStatusListRequestType;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgSelector;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgStatusListType;
-import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
 
@@ -111,24 +108,19 @@ public class MsgBoxPortImpl implements MsgBoxPortType {
 		log.info("Executing operation getStatusList");
 		validateGetStatusListRequest(statusListRequest);
 
-		String msgBoxRequestId = XtaIdGenerator.generateRequestId().toString();
-		MsgStatusListType statusListResponse = new MsgStatusListType();
-
 		if (validator.isNotNull(statusListRequest.getMsgSelector(), "msgSelector")) {
-			msgBoxResponseHeader.value = createInvalidSearchArgsResponseHeader(msgBoxRequestId);
-			return statusListResponse;
+			msgBoxResponseHeader.value = responseMapper.mapMsgBoxResponseTypeError(
+					"SearchArgsInvalid: This test server doesn't support message selection in the 'getStatusList' operation.");
+			return new MsgStatusListType();
 		}
 
-		int maxListItems = requestMapper.mapMaxListItems(statusListRequest);
-		XtaMessageMetaDataListing messageMetaDataListing = messageService.getStatusList(msgBoxRequestId, maxListItems);
-		messageMetaDataListing.messages().forEach(
-				m -> statusListResponse.getMessageMetaData().add(responseMapper.mapMessageMetaDataFromXtaMessageMetaData(m))
-		);
-
-		msgBoxResponseHeader.value = responseMapper.mapMsgBoxResponseTypeFromXtaMessageMetaDataListing(messageMetaDataListing);
-		return statusListResponse;
+		var request = requestMapper.mapMessageMetaDataListingRequest(statusListRequest, authorIdentifier);
+		var listing = messageService.getStatusList(request);
+		msgBoxResponseHeader.value = responseMapper.mapMsgBoxResponseType(listing);
+		return responseMapper.mapMsgStatusListType(listing);
 	}
 
+
 	private void validateGetStatusListRequest(MsgBoxStatusListRequestType statusListRequest) throws XTAWSTechnicalProblemException {
 		if (!(
 				validator.isNotNull(statusListRequest.getListForm(), "listForm")
@@ -137,15 +129,6 @@ public class MsgBoxPortImpl implements MsgBoxPortType {
 		}
 	}
 
-	private MsgBoxResponseType createInvalidSearchArgsResponseHeader(String msgBoxRequestId) {
-		var responseHeader = new MsgBoxResponseType();
-		responseHeader.setMsgBoxRequestID(msgBoxRequestId);
-		var noMessagesAvailable = new MsgBoxResponseType.NoMessageAvailable();
-		noMessagesAvailable.setReason("SearchArgsInvalid: This test server doesn't support message selection in the 'getStatusList' operation.");
-		responseHeader.setNoMessageAvailable(noMessagesAvailable);
-		return responseHeader;
-	}
-
 	/*
 	 * (non-Javadoc)
 	 * @see genv3.de.xoev.transport.xta.x211.MsgBoxPortType#getNextMessage(genv3.eu.osci.ws.x2008.x05.transport.

src/main/java/de/ozgcloud/xta/test/app/service/XtaMessageService.java

@@ -9,6 +9,7 @@ import de.ozgcloud.xta.test.app.data.XtaMessageRepository;
 import de.ozgcloud.xta.test.app.model.XtaMessage;
 import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
 import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
+import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListingRequest;
 import lombok.RequiredArgsConstructor;
 
 @Service
@@ -20,11 +21,12 @@ public class XtaMessageService {
 		messageRepository.save(message);
 	}
 
-	public XtaMessageMetaDataListing getStatusList(String requestId, int maxListItems) {
+	public XtaMessageMetaDataListing getStatusList(XtaMessageMetaDataListingRequest listingRequest) {
 		return XtaMessageMetaDataListing.builder()
-				.requestId(requestId)
-				.pendingMessageCount(messageRepository.count())
-				.messages(getMetaData(messageRepository.findAllLimitedTo(maxListItems)))
+				.pendingMessageCount(messageRepository.countByReaderIdentifierValue(listingRequest.clientIdentifierValue()))
+				.messages(getMetaData(messageRepository.findByReaderIdentifierValueLimitedTo(
+						listingRequest.clientIdentifierValue(),
+						listingRequest.maxListItems())))
 				.build();
 	}
 

src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageRepositoryTest.java → src/test/java/de/ozgcloud/xta/test/app/data/XtaMessageRepositoryTest.java

-package de.ozgcloud.xta.test.app.service;
+package de.ozgcloud.xta.test.app.data;
 
-import static de.ozgcloud.xta.test.app.service.XtaMessageTestFactory.*;
+import static de.ozgcloud.xta.test.app.mapper.XtaMessageTestFactory.*;
+import static de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory.*;
 import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
 
 import java.util.List;
+import java.util.stream.Stream;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -11,22 +14,25 @@ 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.Spy;
 
-import de.ozgcloud.xta.test.app.data.XtaMessageRepository;
+import de.ozgcloud.xta.test.app.mapper.XtaFileTestFactory;
+import de.ozgcloud.xta.test.app.mapper.XtaMessageTestFactory;
+import de.ozgcloud.xta.test.app.model.Identifier;
 import de.ozgcloud.xta.test.app.model.XtaFile;
 import de.ozgcloud.xta.test.app.model.XtaMessage;
+import de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory;
 
 public class XtaMessageRepositoryTest {
 
+	@Spy
+	@InjectMocks
 	private XtaMessageRepository xtaMessageRepository;
 
 	@DisplayName("save")
 	@Nested
 	class TestSave {
-		@BeforeEach
-		void beforeEach() {
-			xtaMessageRepository = new XtaMessageRepository();
-		}
 
 		@Test
 		void shouldSaveMessage() {
@@ -69,17 +75,15 @@ public class XtaMessageRepositoryTest {
 		public static final String MESSAGE_ID = "messageId";
 		private XtaFile messageFile;
 		private XtaFile attachmentFile;
-		private XtaMessage message;
 
 		@BeforeEach
 		void beforeEach() {
-			messageFile = XtaFileTestFactory.createXtaFile();
-			attachmentFile = XtaFileTestFactory.createXtaFile();
-			message = XtaMessageTestFactory.createBuilder(MESSAGE_ID)
+			messageFile = XtaFileTestFactory.create();
+			attachmentFile = XtaFileTestFactory.create();
+			var message = XtaMessageTestFactory.createBuilder(MESSAGE_ID)
 					.messageFile(messageFile)
 					.attachmentFiles(List.of(attachmentFile))
 					.build();
-			xtaMessageRepository = new XtaMessageRepository();
 			xtaMessageRepository.save(message);
 		}
 
@@ -95,12 +99,12 @@ public class XtaMessageRepositoryTest {
 		}
 	}
 
-	@DisplayName("find all limited to")
+	@DisplayName("find by reader identifier value limited to")
 	@Nested
-	class TestFindAllLimitedTo {
+	class TestFindByReaderIdentifierValueLimitedTo {
+
 		@BeforeEach
 		void beforeEach() {
-			xtaMessageRepository = new XtaMessageRepository();
 			xtaMessageRepository.save(XtaMessageTestFactory.create("1"));
 			xtaMessageRepository.save(XtaMessageTestFactory.create("2"));
 			xtaMessageRepository.save(XtaMessageTestFactory.create("3"));
@@ -110,7 +114,7 @@ public class XtaMessageRepositoryTest {
 		@ParameterizedTest
 		@ValueSource(ints = { 0, 1, 2 })
 		void shouldReturnLimit(int limit) {
-			var result = xtaMessageRepository.findAllLimitedTo(limit);
+			var result = xtaMessageRepository.findByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), limit);
 
 			assertThat(result).hasSize(limit);
 		}
@@ -119,27 +123,81 @@ public class XtaMessageRepositoryTest {
 		@ParameterizedTest
 		@ValueSource(ints = { 3, 4, 5 })
 		void shouldReturnAll(int limit) {
-			var result = xtaMessageRepository.findAllLimitedTo(limit);
+			var result = xtaMessageRepository.findByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), limit);
 
 			assertThat(result).hasSize(3);
 		}
 
+		@DisplayName("should not find any with unknown reader identifier")
+		@Test
+		void shouldNotFindAnyWithUnknownReaderIdentifier() {
+			var result = xtaMessageRepository.findByReaderIdentifierValueLimitedTo("unknown", 1);
+
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+	@DisplayName("count by reader identifier value")
+	@Nested
+	class TestCountByReaderIdentifierValue {
+		@BeforeEach
+		void beforeEach() {
+			doReturn(Stream.of(XtaMessageTestFactory.create("1"), XtaMessageTestFactory.create("2"),
+					XtaMessageTestFactory.create("3"))).when(xtaMessageRepository).findByReaderIdentifierValue(READER_IDENTIFIER.value());
+		}
+
+		@DisplayName("should return")
+		@Test
+		void shouldReturn() {
+			var count = xtaMessageRepository.countByReaderIdentifierValue(READER_IDENTIFIER.value());
+
+			assertThat(count).isEqualTo(3);
+		}
+
 	}
 
-	@DisplayName("count")
+	@DisplayName("find by reader identifier value")
 	@Nested
-	class TestCount {
+	class TestFindByReaderIdentifierValue {
+		private static final String OTHER_READER_IDENTIFIER = "readerIdentifier";
+
 		@BeforeEach
 		void beforeEach() {
 			xtaMessageRepository = new XtaMessageRepository();
 			xtaMessageRepository.save(XtaMessageTestFactory.create("1"));
 			xtaMessageRepository.save(XtaMessageTestFactory.create("2"));
 			xtaMessageRepository.save(XtaMessageTestFactory.create("3"));
+			xtaMessageRepository.save(XtaMessageTestFactory.createBuilder()
+					.metaData(XtaMessageMetaDataTestFactory.createBuilder()
+							.readerIdentifier(Identifier.builder().value(OTHER_READER_IDENTIFIER).build())
+							.build())
+					.build());
+		}
+
+		@DisplayName("should return message for reader identifier")
+		@Test
+		void shouldReturnMessageForReaderIdentifier() {
+			var result = xtaMessageRepository.findByReaderIdentifierValue(READER_IDENTIFIER.value()).toList();
+
+			assertThat(result).hasSize(3);
 		}
 
+		@DisplayName("should return messages for other reader identifier")
 		@Test
-		void shouldReturnCount() {
-			assertThat(xtaMessageRepository.count()).isEqualTo(3);
+		void shouldReturnMessagesForOtherReaderIdentifier() {
+			var result = xtaMessageRepository.findByReaderIdentifierValue(OTHER_READER_IDENTIFIER).toList();
+
+			assertThat(result).hasSize(1);
 		}
+
+		@DisplayName("should return no messages for unknown reader identifier")
+		@Test
+		void shouldReturnNoMessagesForUnknownReaderIdentifier() {
+			var result = xtaMessageRepository.findByReaderIdentifierValue("unknown").toList();
+
+			assertThat(result).isEmpty();
+		}
+
 	}
 }

src/test/java/de/ozgcloud/xta/test/app/mapper/PartyTypeTestFactory.java

+package de.ozgcloud.xta.test.app.mapper;
+
+
+import static de.ozgcloud.xta.test.app.service.MessageMetaDataTestFactory.*;
+
+import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
+import genv3.eu.osci.ws.x2014.x10.transport.PartyType;
+
+public class PartyTypeTestFactory {
+
+	public static PartyType create() {
+		var partyIdentifier = new PartyType();
+		partyIdentifier.setIdentifier(createIdentifier());
+		return partyIdentifier;
+	}
+
+	private static PartyIdentifierType createIdentifier() {
+		var identifier = new PartyIdentifierType();
+		identifier.setName(READER_IDENTIFIER.getName());
+		identifier.setCategory(READER_IDENTIFIER.getCategory());
+		identifier.setValue(READER_IDENTIFIER.getValue());
+		return identifier;
+	}
+
+}

src/test/java/de/ozgcloud/xta/test/app/service/RequestMapperTest.java → src/test/java/de/ozgcloud/xta/test/app/mapper/RequestMapperTest.java

-package de.ozgcloud.xta.test.app.service;
+package de.ozgcloud.xta.test.app.mapper;
 
+import static de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory.*;
 import static org.assertj.core.api.Assertions.*;
 
 import java.nio.file.Files;
@@ -11,9 +12,15 @@ import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.mapstruct.factory.Mappers;
 
-import de.ozgcloud.xta.test.app.mapper.RequestMapper;
 import de.ozgcloud.xta.test.app.model.Identifier;
 import de.ozgcloud.xta.test.app.model.XtaFile;
+import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListingRequest;
+import de.ozgcloud.xta.test.app.service.AttributedURITypeTestFactory;
+import de.ozgcloud.xta.test.app.service.ContentTypeTestFactory;
+import de.ozgcloud.xta.test.app.service.GenericContentContainerTestFactoy;
+import de.ozgcloud.xta.test.app.service.MessageMetaDataTestFactory;
+import de.ozgcloud.xta.test.app.service.MsgBoxStatusListRequestTypeTestFactory;
+import de.ozgcloud.xta.test.app.service.QualifierTypeBusinessScenarioTestFactory;
 import genv3.de.xoev.transport.xta.x211.ContentType;
 import genv3.de.xoev.transport.xta.x211.GenericContentContainer;
 import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxFetchRequest;
@@ -104,13 +111,11 @@ public class RequestMapperTest {
 			messageMetaData.getQualifier().setBusinessScenario(businessScenario);
 
 			var xtaMessageMetaData = requestMapper.mapXtaMessageMetaData(messageMetaData);
-			var mappedBusinessScenario = xtaMessageMetaData.businessScenario();
 
-			assertThat(mappedBusinessScenario.businessScenarioCode()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_CODE);
-			assertThat(mappedBusinessScenario.name()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_NAME);
-			assertThat(mappedBusinessScenario.listURI()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_LIST_URI);
-			assertThat(mappedBusinessScenario.listVersionID()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_LIST_VERSION_ID);
-			assertThat(mappedBusinessScenario.isDefinedCode()).isTrue();
+			assertThat(xtaMessageMetaData.businessScenarioCode()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_CODE);
+			assertThat(xtaMessageMetaData.businessScenarioName()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_NAME);
+			assertThat(xtaMessageMetaData.businessScenarioListUri()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_LIST_URI);
+			assertThat(xtaMessageMetaData.businessScenarioListVersionId()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_LIST_VERSION_ID);
 		}
 
 		@DisplayName("Should map an undefined business scenario from MessageMetaData")
@@ -120,10 +125,9 @@ public class RequestMapperTest {
 			messageMetaData.getQualifier().setBusinessScenario(businessScenario);
 
 			var xtaMessageMetaData = requestMapper.mapXtaMessageMetaData(messageMetaData);
-			var mappedBusinessScenario = xtaMessageMetaData.businessScenario();
 
-			assertThat(mappedBusinessScenario.businessScenarioCode()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_CODE);
-			assertThat(mappedBusinessScenario.isDefinedCode()).isFalse();
+			assertThat(xtaMessageMetaData.businessScenarioCode()).isEqualTo(QualifierTypeBusinessScenarioTestFactory.BUSINESS_SCENARIO_CODE);
+			assertThat(xtaMessageMetaData.businessScenarioListUri()).isNull();
 		}
 	}
 
@@ -188,4 +192,31 @@ public class RequestMapperTest {
 		}
 	}
 
+	@DisplayName("map message meta data listing request")
+	@Nested
+	class TestMapMessageMetaDataListingRequest {
+		private final int MAX_LIST_ITEMS = 10;
+
+		@DisplayName("should map client identifier value")
+		@Test
+		void shouldMapClientIdentifierValue() {
+			var result = doMapping();
+
+			assertThat(result.clientIdentifierValue()).isEqualTo(READER_IDENTIFIER.value());
+		}
+
+		@DisplayName("should max max list items")
+		@Test
+		void shouldMaxMaxListItems() {
+			var result = doMapping();
+
+			assertThat(result.maxListItems()).isEqualTo(MAX_LIST_ITEMS);
+		}
+
+		private XtaMessageMetaDataListingRequest doMapping() {
+			return requestMapper.mapMessageMetaDataListingRequest(MsgBoxStatusListRequestTypeTestFactory.create(MAX_LIST_ITEMS), PartyTypeTestFactory.create());
+		}
+
+	}
+
 }

src/test/java/de/ozgcloud/xta/test/app/mapper/ResponseMapperTest.java

+package de.ozgcloud.xta.test.app.mapper;
+
+import static de.ozgcloud.xta.test.app.mapper.ResponseMapper.*;
+import static de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory.*;
+import static org.assertj.core.api.Assertions.*;
+
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+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.mapstruct.factory.Mappers;
+
+import de.ozgcloud.xta.test.app.model.XtaFile;
+import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
+import de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory;
+import genv3.de.xoev.transport.xta.x211.ContentType;
+import genv3.eu.osci.ws.x2008.x05.transport.MsgStatusListType;
+import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
+import genv3.eu.osci.ws.x2014.x10.transport.QualifierType;
+import lombok.SneakyThrows;
+
+public class ResponseMapperTest {
+
+	private final ResponseMapper mapper = Mappers.getMapper(ResponseMapper.class);
+
+	@DisplayName("map PartyIdentifierType")
+	@Nested
+	class TestMapPartyIdentifierType {
+
+		@DisplayName("should map type")
+		@Test
+		void shouldMapType() {
+			var result = mapper.mapPartyIdentifierType(AUTHOR_IDENTIFIER);
+
+			assertThat(result.getType()).isEqualTo(IDENTIFIER_TYPE);
+		}
+
+		@DisplayName("should map value")
+		@Test
+		void shouldMapValue() {
+			var result = mapper.mapPartyIdentifierType(AUTHOR_IDENTIFIER);
+
+			assertThat(result.getValue()).isEqualTo(AUTHOR_IDENTIFIER.value());
+		}
+
+		@DisplayName("should map category")
+		@Test
+		void shouldMapCategory() {
+			var result = mapper.mapPartyIdentifierType(AUTHOR_IDENTIFIER);
+
+			assertThat(result.getCategory()).isEqualTo(AUTHOR_IDENTIFIER.category());
+		}
+
+		@DisplayName("should map name")
+		@Test
+		void shouldMapName() {
+			var result = mapper.mapPartyIdentifierType(AUTHOR_IDENTIFIER);
+
+			assertThat(result.getName()).isEqualTo(AUTHOR_IDENTIFIER.name());
+		}
+	}
+
+	@Nested
+	class MapGenericContentContainerFromXtaMessage {
+		private XtaFile messageXtaFile;
+		private XtaFile attachmentXtaFile;
+
+		@BeforeEach
+		void beforeEach() {
+			messageXtaFile = XtaFileTestFactory.create();
+			attachmentXtaFile = XtaFileTestFactory.create();
+		}
+
+		@DisplayName("should map generic content container from xta message")
+		@Test
+		void shouldMap() {
+			var xtaMessage = XtaMessageTestFactory.createBuilder("messageId")
+					.messageFile(messageXtaFile)
+					.attachmentFiles(List.of(attachmentXtaFile))
+					.build();
+
+			var genericContentContainer = mapper.mapGenericContentContainerFromXtaMessage(xtaMessage);
+			var message = genericContentContainer.getContentContainer().getMessage();
+			var attachmentList = genericContentContainer.getContentContainer().getAttachment();
+
+			assertThat(attachmentList).hasSize(1);
+
+			assertContentTypeEqualsXtaFile(message, messageXtaFile);
+			assertContentTypeEqualsXtaFile(attachmentList.getFirst(), attachmentXtaFile);
+		}
+
+		@SneakyThrows
+		void assertContentTypeEqualsXtaFile(ContentType contentType, XtaFile xtaFile) {
+			assertThat(contentType.getId()).isEqualTo(xtaFile.id());
+			assertThat(contentType.getFilename()).isEqualTo(xtaFile.name());
+			assertThat(contentType.getSize()).isEqualTo(xtaFile.size());
+
+			String content = new String(contentType.getValue().getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+			assertThat(content).isEqualTo(XtaFileTestFactory.XTA_CONTENT);
+		}
+	}
+
+	@DisplayName("map MsgBoxResponseType error")
+	@Nested
+	class TestMapMsgBoxResponseTypeError {
+		private final String ERROR_STRING = "some error";
+
+		@DisplayName("should map no message available reason")
+		@Test
+		void shouldMapNoMessageAvailableReason() {
+			var result = mapper.mapMsgBoxResponseTypeError(ERROR_STRING);
+
+			assertThat(result.getNoMessageAvailable().getReason()).isEqualTo(ERROR_STRING);
+		}
+
+		@DisplayName("should map request id")
+		@Test
+		void shouldMapRequestId() {
+			var result = mapper.mapMsgBoxResponseTypeError(ERROR_STRING);
+
+			assertThat(result.getMsgBoxRequestID()).isEqualTo(ResponseMapper.REQUEST_ID);
+		}
+	}
+
+	@DisplayName("map MsgStatusListType")
+	@Nested
+	class TestMapMsgStatusListType {
+		private XtaMessageMetaDataListing xtaMessageMetaDataListing;
+
+		@BeforeEach
+		void beforeEach() {
+			xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
+					.pendingMessageCount(BigInteger.ONE)
+					.messages(List.of(XtaMessageMetaDataTestFactory.create()))
+					.build();
+		}
+
+		@DisplayName("should map message meta data")
+		@Test
+		void shouldMapMessageMetaData() {
+			var result = mapper.mapMsgStatusListType(xtaMessageMetaDataListing);
+
+			assertThat(result.getMessageMetaData()).hasSize(1);
+		}
+
+		@DisplayName("should map message size")
+		@Test
+		void shouldMapMessageSize() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getMsgSize()).isEqualTo(MESSAGE_SIZE);
+		}
+
+		@DisplayName("should map service")
+		@Test
+		void shouldMapService() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getQualifier().getService()).isEqualTo(SERVICE);
+		}
+
+		@DisplayName("with defined business scenario")
+		@Nested
+		class TestWithDefinedBusinessScenario {
+
+			@BeforeEach
+			void beforeEach() {
+				xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
+						.pendingMessageCount(BigInteger.ONE)
+						.messages(List.of(XtaMessageMetaDataTestFactory.create()))
+						.build();
+			}
+
+			@DisplayName("should map code")
+			@Test
+			void shouldMapCode() {
+				var result = mapFirstMessageMetaDataBusinessScenario();
+
+				assertThat(result.getDefined().getCode()).isEqualTo(BUSINESS_SCENARIO_CODE);
+			}
+
+			@DisplayName("should map name")
+			@Test
+			void shouldMapName() {
+				var result = mapFirstMessageMetaDataBusinessScenario();
+
+				assertThat(result.getDefined().getName()).isEqualTo(BUSINESS_SCENARIO_NAME);
+			}
+
+			@DisplayName("should map list uri")
+			@Test
+			void shouldMapListUri() {
+				var result = mapFirstMessageMetaDataBusinessScenario();
+
+				assertThat(result.getDefined().getListURI()).isEqualTo(BUSINESS_SCENARIO_LIST_URI);
+			}
+
+			@DisplayName("should map list version id")
+			@Test
+			void shouldMapListVersionId() {
+				var result = mapFirstMessageMetaDataBusinessScenario();
+
+				assertThat(result.getDefined().getListVersionID()).isEqualTo(BUSINESS_SCENARIO_LIST_VERSION_ID);
+			}
+		}
+
+		@DisplayName("with undefined business scenario")
+		@Nested
+		class TestWithUndefinedBusinessScenario {
+			@BeforeEach
+			void mock() {
+				xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
+						.pendingMessageCount(BigInteger.ONE)
+						.messages(List.of(XtaMessageMetaDataTestFactory.createBuilder()
+								.businessScenarioListUri(null)
+								.build()))
+						.build();
+
+			}
+
+			@DisplayName("should map code")
+			@Test
+			void shouldMapCode() {
+				var result = mapFirstMessageMetaDataBusinessScenario();
+
+				assertThat(result.getUndefined()).isEqualTo(BUSINESS_SCENARIO_CODE);
+			}
+
+			@DisplayName("should map defined null")
+			@Test
+			void shouldMapDefinedNull() {
+				var result = mapFirstMessageMetaDataBusinessScenario();
+
+				assertThat(result.getDefined()).isNull();
+			}
+		}
+
+		@DisplayName("should map message type code")
+		@Test
+		void shouldMapMessageTypeCode() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getQualifier().getMessageType().getCode()).isEqualTo(MESSAGE_TYPE_CODE);
+		}
+
+		@DisplayName("should map message type list uri")
+		@Test
+		void shouldMapMessageTypeListUri() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getQualifier().getMessageType().getListURI()).isEqualTo(MESSAGE_TYPE_LIST_URI);
+		}
+
+		@DisplayName("should map message type list version id")
+		@Test
+		void shouldMapMessageTypeListVersionId() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getQualifier().getMessageType().getListVersionID()).isEqualTo(MESSAGE_TYPE_LIST_VERSION_ID);
+		}
+
+		@DisplayName("should map author identifier")
+		@Test
+		void shouldMapAuthorIdentifier() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getOriginators().getAuthor().getIdentifier())
+					.usingRecursiveComparison()
+					.isEqualTo(mapper.mapPartyIdentifierType(AUTHOR_IDENTIFIER));
+		}
+
+		@DisplayName("should map reader identifier")
+		@Test
+		void shouldMapReaderIdentifier() {
+			var result = mapFirstMessageMetaData();
+
+			assertThat(result.getDestinations().getReader().getIdentifier())
+					.usingRecursiveComparison()
+					.isEqualTo(mapper.mapPartyIdentifierType(READER_IDENTIFIER));
+		}
+
+		private MsgStatusListType doMapping() {
+			return mapper.mapMsgStatusListType(xtaMessageMetaDataListing);
+		}
+
+		private MessageMetaData mapFirstMessageMetaData() {
+			return doMapping().getMessageMetaData().getFirst();
+		}
+
+		private QualifierType.BusinessScenario mapFirstMessageMetaDataBusinessScenario() {
+			return mapFirstMessageMetaData().getQualifier().getBusinessScenario();
+		}
+	}
+
+	@DisplayName("map MsgBoxResponseType")
+	@Nested
+	class TestMapMsgBoxResponseType {
+		private XtaMessageMetaDataListing xtaMessageMetaDataListing;
+
+		@DisplayName("with no pending messages")
+		@Nested
+		class TestWithNoPendingMessages {
+			@BeforeEach
+			void beforeEach() {
+				xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
+						.pendingMessageCount(BigInteger.ZERO)
+						.messages(List.of())
+						.build();
+			}
+
+			@DisplayName("should set no message available reason")
+			@Test
+			void shouldSetNoMessageAvailableReason() {
+				var msgBoxResponseType = mapper.mapMsgBoxResponseType(xtaMessageMetaDataListing);
+
+				assertThat(msgBoxResponseType.getNoMessageAvailable().getReason()).isEqualTo(ResponseMapper.NO_MESSAGES_REASON);
+			}
+
+			@DisplayName("should set items pending to null")
+			@Test
+			void shouldSetItemsPendingToNull() {
+				var msgBoxResponseType = mapper.mapMsgBoxResponseType(xtaMessageMetaDataListing);
+
+				assertThat(msgBoxResponseType.getItemsPending()).isNull();
+			}
+		}
+
+		@DisplayName("with pending messages")
+		@Nested
+		class TestWithPendingMessages {
+			@BeforeEach
+			void beforeEach() {
+				xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
+						.pendingMessageCount(BigInteger.ONE)
+						.messages(List.of(XtaMessageMetaDataTestFactory.create()))
+						.build();
+			}
+
+			@DisplayName("should set items pending")
+			@Test
+			void shouldSetItemsPending() {
+				var msgBoxResponseType = mapper.mapMsgBoxResponseType(xtaMessageMetaDataListing);
+
+				assertThat(msgBoxResponseType.getItemsPending()).isEqualTo(BigInteger.ONE);
+			}
+
+			@DisplayName("should set no message available to null")
+			@Test
+			void shouldSetNoMessageAvailableToNull() {
+				var msgBoxResponseType = mapper.mapMsgBoxResponseType(xtaMessageMetaDataListing);
+
+				assertThat(msgBoxResponseType.getNoMessageAvailable()).isNull();
+			}
+		}
+	}
+}

src/test/java/de/ozgcloud/xta/test/app/service/XtaFileTestFactory.java → src/test/java/de/ozgcloud/xta/test/app/mapper/XtaFileTestFactory.java

-package de.ozgcloud.xta.test.app.service;
+package de.ozgcloud.xta.test.app.mapper;
 
 import java.io.File;
 import java.math.BigInteger;
 
 import de.ozgcloud.xta.test.app.model.XtaFile;
+import de.ozgcloud.xta.test.app.service.TempFileTestFactory;
 
 public class XtaFileTestFactory {
 	static final String NAME = "Test_File";
 	static final String XTA_CONTENT = "slkafj3jifsdasx";
 	static final String ZIP_CONTENT_TYPE = "application/zip";
 
-	static XtaFile createXtaFile() {
-		return createXtaFileBuilder().build();
+	public static XtaFile create() {
+		return createBuilder().build();
 	}
 
-	static XtaFile.XtaFileBuilder createXtaFileBuilder() {
+	static XtaFile.XtaFileBuilder createBuilder() {
 		File tfile = TempFileTestFactory.createFile(XTA_CONTENT);
 		return XtaFile.builder()
 				.name(NAME)

src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageTestFactory.java → src/test/java/de/ozgcloud/xta/test/app/mapper/XtaMessageTestFactory.java

-package de.ozgcloud.xta.test.app.service;
+package de.ozgcloud.xta.test.app.mapper;
 
 import java.util.List;
 
 import de.ozgcloud.xta.test.app.model.XtaMessage;
+import de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory;
 
 public class XtaMessageTestFactory {
 	public static final String MESSAGE_ID_1 = "status_1";
@@ -12,10 +13,17 @@ public class XtaMessageTestFactory {
 		return createBuilder(messageId).build();
 	}
 
+	public static XtaMessage.XtaMessageBuilder createBuilder() {
+		return XtaMessage.builder()
+				.metaData(XtaMessageMetaDataTestFactory.create())
+				.messageFile(XtaFileTestFactory.create())
+				.attachmentFiles(List.of(XtaFileTestFactory.create()));
+	}
+
 	public static XtaMessage.XtaMessageBuilder createBuilder(String messageId) {
 		return XtaMessage.builder()
 				.metaData(XtaMessageMetaDataTestFactory.create(messageId))
-				.messageFile(XtaFileTestFactory.createXtaFile())
-				.attachmentFiles(List.of(XtaFileTestFactory.createXtaFile()));
+				.messageFile(XtaFileTestFactory.create())
+				.attachmentFiles(List.of(XtaFileTestFactory.create()));
 	}
 }

src/test/java/de/ozgcloud/xta/test/app/service/ResponseMapperTest.java

-package de.ozgcloud.xta.test.app.service;
-
-import static org.assertj.core.api.Assertions.*;
-
-import java.math.BigInteger;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-
-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.mapstruct.factory.Mappers;
-
-import de.ozgcloud.xta.test.app.mapper.ResponseMapper;
-import de.ozgcloud.xta.test.app.model.Identifier;
-import de.ozgcloud.xta.test.app.model.XtaFile;
-import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
-import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
-import genv3.de.xoev.transport.xta.x211.ContentType;
-import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
-import lombok.SneakyThrows;
-
-public class ResponseMapperTest {
-
-	private final ResponseMapper mapper = Mappers.getMapper(ResponseMapper.class);
-
-	@Nested
-	class MapMessageMetaDataFromXtaMessageMetaData {
-		public static final String MESSAGE_ID = "messageId";
-
-		private XtaMessageMetaData xtaMessageMetaData;
-
-		@DisplayName("should map messageMetaData")
-		@Test
-		void shouldMapMessageId() {
-			xtaMessageMetaData = XtaMessageMetaDataTestFactory.create(MESSAGE_ID);
-
-			var messageMetaData = mapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessageMetaData);
-
-			assertThat(messageMetaData.getMsgIdentification().getMessageID().getValue()).isEqualTo(MESSAGE_ID);
-			assertThat(messageMetaData.getQualifier().getService()).isEqualTo(XtaMessageMetaDataTestFactory.SERVICE);
-			assertThat(messageMetaData.getMsgSize()).isEqualTo(xtaMessageMetaData.messageSize());
-		}
-
-		@DisplayName("should map defined business scenario")
-		@Test
-		void shouldMapDefinedBusinessScenario() {
-			xtaMessageMetaData = XtaMessageMetaDataTestFactory.createBuilder(MESSAGE_ID)
-					.businessScenario(XtaMessageMetaDataTestFactory.createDefinedBusinessScenario())
-					.build();
-
-			var messageMetaData = mapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessageMetaData);
-			var businessScenario = messageMetaData.getQualifier().getBusinessScenario();
-
-			assertThat(businessScenario.getDefined().getCode()).isEqualTo(XtaMessageMetaDataTestFactory.BUSINESS_SCENARIO_CODE);
-			assertThat(businessScenario.getDefined().getName()).isEqualTo(XtaMessageMetaDataTestFactory.BUSINESS_SCENARIO_NAME);
-			assertThat(businessScenario.getDefined().getListURI()).isEqualTo(XtaMessageMetaDataTestFactory.BUSINESS_SCENARIO_LIST_URI);
-			assertThat(businessScenario.getDefined().getListVersionID()).isEqualTo(XtaMessageMetaDataTestFactory.BUSINESS_SCENARIO_LIST_VERSION_ID);
-			assertThat(businessScenario.getUndefined()).isNull();
-		}
-
-		@DisplayName("should map undefined business scenario")
-		@Test
-		void shouldMapUndefinedBusinessScenario() {
-			xtaMessageMetaData = XtaMessageMetaDataTestFactory.createBuilder(MESSAGE_ID)
-					.businessScenario(XtaMessageMetaDataTestFactory.createUndefinedBusinessScenario())
-					.build();
-
-			var messageMetaData = mapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessageMetaData);
-			var businessScenario = messageMetaData.getQualifier().getBusinessScenario();
-
-			assertThat(businessScenario.getDefined()).isNull();
-			assertThat(businessScenario.getUndefined()).isEqualTo(XtaMessageMetaDataTestFactory.BUSINESS_SCENARIO_CODE);
-		}
-
-		@DisplayName("should map qualifier message type")
-		@Test
-		void shouldMapMessageType() {
-			xtaMessageMetaData = XtaMessageMetaDataTestFactory.create(MESSAGE_ID);
-
-			var messageMetaData = mapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessageMetaData);
-			var messageType = messageMetaData.getQualifier().getMessageType();
-
-			assertThat(messageType.getCode()).isEqualTo(XtaMessageMetaDataTestFactory.MESSAGE_TYPE_CODE);
-			assertThat(messageType.getPayloadSchema()).isEqualTo(XtaMessageMetaDataTestFactory.MESSAGE_PAYLOAD_SCHEMA);
-			assertThat(messageType.getListURI()).isEqualTo(ResponseMapper.MESSAGE_TYPE_LIST_URI);
-			assertThat(messageType.getListVersionID()).isEqualTo(ResponseMapper.MESSAGE_TYPE_LIST_VERSION_ID);
-		}
-
-		@DisplayName("should map author and reader identifier")
-		@Test
-		void shouldMapIdentifier() {
-			xtaMessageMetaData = XtaMessageMetaDataTestFactory.create(MESSAGE_ID);
-
-			var messageMetaData = mapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessageMetaData);
-			var authorIdentifier = messageMetaData.getOriginators().getAuthor().getIdentifier();
-			var readerIdentifier = messageMetaData.getDestinations().getReader().getIdentifier();
-
-			assertIdentifiersAreEqual(authorIdentifier, XtaMessageMetaDataTestFactory.AUTHOR_IDENTIFIER);
-			assertIdentifiersAreEqual(readerIdentifier, XtaMessageMetaDataTestFactory.READER_IDENTIFIER);
-		}
-
-		void assertIdentifiersAreEqual(PartyIdentifierType identifierType, Identifier identifier) {
-			assertThat(identifierType.getName()).isEqualTo(identifier.name());
-			assertThat(identifierType.getCategory()).isEqualTo(identifier.category());
-			assertThat(identifierType.getValue()).isEqualTo(identifier.value());
-			assertThat(identifierType.getType()).isEqualTo(ResponseMapper.IDENTIFIER_TYPE);
-		}
-	}
-
-	@Nested
-	class MapGenericContentContainerFromXtaMessage {
-		private XtaFile messageXtaFile;
-		private XtaFile attachmentXtaFile;
-
-		@BeforeEach
-		void beforeEach() {
-			messageXtaFile = XtaFileTestFactory.createXtaFile();
-			attachmentXtaFile = XtaFileTestFactory.createXtaFile();
-		}
-
-		@DisplayName("should map generic content container from xta message")
-		@Test
-		void shouldMap() {
-			var xtaMessage = XtaMessageTestFactory.createBuilder("messageId")
-					.messageFile(messageXtaFile)
-					.attachmentFiles(List.of(attachmentXtaFile))
-					.build();
-
-			var genericContentContainer = mapper.mapGenericContentContainerFromXtaMessage(xtaMessage);
-			var message = genericContentContainer.getContentContainer().getMessage();
-			var attachmentList = genericContentContainer.getContentContainer().getAttachment();
-
-			assertThat(attachmentList).hasSize(1);
-
-			assertContentTypeEqualsXtaFile(message, messageXtaFile);
-			assertContentTypeEqualsXtaFile(attachmentList.getFirst(), attachmentXtaFile);
-		}
-
-		@SneakyThrows
-		void assertContentTypeEqualsXtaFile(ContentType contentType, XtaFile xtaFile) {
-			assertThat(contentType.getId()).isEqualTo(xtaFile.id());
-			assertThat(contentType.getFilename()).isEqualTo(xtaFile.name());
-			assertThat(contentType.getSize()).isEqualTo(xtaFile.size());
-
-			String content = new String(contentType.getValue().getInputStream().readAllBytes(), StandardCharsets.UTF_8);
-			assertThat(content).isEqualTo(XtaFileTestFactory.XTA_CONTENT);
-		}
-	}
-
-	@Nested
-	class MapMsgBoxResponseTypeFromXtaMessageMetaDataListing {
-		private XtaMessageMetaDataListing xtaMessageMetaDataListing;
-
-		@DisplayName("should have no messages available when mapping empty XtaMetaDataListing")
-		@Test
-		void shouldHaveNoMessageAvailable() {
-			xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
-					.requestId("requestId")
-					.pendingMessageCount(BigInteger.ZERO)
-					.messages(List.of())
-					.build();
-
-			var msgBoxResponseType = mapper.mapMsgBoxResponseTypeFromXtaMessageMetaDataListing(xtaMessageMetaDataListing);
-
-			assertThat(msgBoxResponseType.getNoMessageAvailable()).isNotNull();
-			assertThat(msgBoxResponseType.getNoMessageAvailable().getReason()).startsWith("NoMatch");
-			assertThat(msgBoxResponseType.getItemsPending()).isNull();
-		}
-
-		@DisplayName("should have items pending when mapping filled XtaMetaDatalisting")
-		@Test
-		void shouldHaveItemsPending() {
-			xtaMessageMetaDataListing = XtaMessageMetaDataListing.builder()
-					.requestId("requestId")
-					.pendingMessageCount(BigInteger.ONE)
-					.messages(List.of(XtaMessageMetaDataTestFactory.create("messageId")))
-					.build();
-
-			var msgBoxResponseType = mapper.mapMsgBoxResponseTypeFromXtaMessageMetaDataListing(xtaMessageMetaDataListing);
-
-			assertThat(msgBoxResponseType.getItemsPending()).isEqualTo(BigInteger.ONE);
-			assertThat(msgBoxResponseType.getNoMessageAvailable()).isNull();
-		}
-	}
-}

src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageMetaDataTestFactory.java

@@ -6,6 +6,7 @@ import de.ozgcloud.xta.test.app.model.Identifier;
 import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
 
 public class XtaMessageMetaDataTestFactory {
+	public static final String DEFAULT_MESSAGE_ID = "defaultMessageId";
 	public static final Identifier AUTHOR_IDENTIFIER = createIdentifier("author", "AUTHOR");
 	public static final Identifier READER_IDENTIFIER = createIdentifier("reader", "READER");
 	public static final String SERVICE = "Service";
@@ -15,39 +16,31 @@ public class XtaMessageMetaDataTestFactory {
 	public static final String BUSINESS_SCENARIO_LIST_VERSION_ID = "BusinessScenarioListVersionID";
 	public static final String MESSAGE_TYPE_CODE = "MessageTypeCode";
 	public static final String MESSAGE_PAYLOAD_SCHEMA = "MessageTypePayloadSchema";
+	public static final BigInteger MESSAGE_SIZE = BigInteger.valueOf(3000);
+
+	public static XtaMessageMetaData create() {
+		return createBuilder().build();
+	}
 
 	public static XtaMessageMetaData create(String messageId) {
-		return createBuilder(messageId).build();
+		return createBuilder()
+				.messageId(messageId)
+				.build();
 	}
 
-	public static XtaMessageMetaData.XtaMessageMetaDataBuilder createBuilder(String messageId) {
+	public static XtaMessageMetaData.XtaMessageMetaDataBuilder createBuilder() {
 		return XtaMessageMetaData.builder()
-				.messageId(messageId)
+				.messageId(DEFAULT_MESSAGE_ID)
 				.authorIdentifier(AUTHOR_IDENTIFIER)
 				.readerIdentifier(READER_IDENTIFIER)
 				.service(SERVICE)
-				.businessScenario(createUndefinedBusinessScenario())
+				.businessScenarioCode(BUSINESS_SCENARIO_CODE)
+				.businessScenarioName(BUSINESS_SCENARIO_NAME)
+				.businessScenarioListUri(BUSINESS_SCENARIO_LIST_URI)
+				.businessScenarioListVersionId(BUSINESS_SCENARIO_LIST_VERSION_ID)
 				.messageTypeCode(MESSAGE_TYPE_CODE)
 				.messageTypePayloadSchema(MESSAGE_PAYLOAD_SCHEMA)
-				.messageSize(BigInteger.ZERO);
-	}
-
-	public static XtaMessageMetaData.BusinessScenario createDefinedBusinessScenario() {
-		return new XtaMessageMetaData.BusinessScenario(
-				BUSINESS_SCENARIO_CODE,
-				BUSINESS_SCENARIO_NAME,
-				BUSINESS_SCENARIO_LIST_URI,
-				BUSINESS_SCENARIO_LIST_VERSION_ID,
-				true);
-	}
-
-	public static XtaMessageMetaData.BusinessScenario createUndefinedBusinessScenario() {
-		return new XtaMessageMetaData.BusinessScenario(
-				BUSINESS_SCENARIO_CODE,
-				null,
-				null,
-				null,
-				false);
+				.messageSize(MESSAGE_SIZE);
 	}
 
 	private static Identifier createIdentifier(String value, String category) {

src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageServiceTest.java

 package de.ozgcloud.xta.test.app.service;
 
-import static de.ozgcloud.xta.test.app.service.XtaMessageTestFactory.*;
+import static de.ozgcloud.xta.test.app.mapper.XtaMessageTestFactory.*;
+import static de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory.*;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
@@ -15,8 +16,10 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 
 import de.ozgcloud.xta.test.app.data.XtaMessageRepository;
+import de.ozgcloud.xta.test.app.mapper.XtaMessageTestFactory;
 import de.ozgcloud.xta.test.app.model.XtaMessage;
 import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
+import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListingRequest;
 
 public class XtaMessageServiceTest {
 	@Mock
@@ -46,10 +49,15 @@ public class XtaMessageServiceTest {
 
 	@Nested
 	class GetStatusList {
-		public static final String REQUEST_ID = "request_1";
+
 		private final int MAX_LIST_ITEMS = 50;
 		private final int MESSAGE_COUNT = 2;
 
+		private final XtaMessageMetaDataListingRequest messageMetaDataListingRequest = XtaMessageMetaDataListingRequest.builder()
+				.clientIdentifierValue(READER_IDENTIFIER.value())
+				.maxListItems(MAX_LIST_ITEMS)
+				.build();
+
 		private XtaMessage message1;
 		private XtaMessage message2;
 
@@ -57,15 +65,9 @@ public class XtaMessageServiceTest {
 		void beforeEach() {
 			message1 = XtaMessageTestFactory.create(MESSAGE_ID_1);
 			message2 = XtaMessageTestFactory.create(MESSAGE_ID_2);
-			when(messageRepository.findAllLimitedTo(MAX_LIST_ITEMS)).thenReturn(List.of(message1, message2));
-			when(messageRepository.count()).thenReturn(BigInteger.valueOf(MESSAGE_COUNT));
-		}
-
-		@Test
-		void shouldSetRequestId() {
-			var statusList = getStatusList();
 
-			assertThat(statusList.requestId()).isEqualTo(REQUEST_ID);
+			when(messageRepository.findByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), MAX_LIST_ITEMS)).thenReturn(List.of(message1, message2));
+			when(messageRepository.countByReaderIdentifierValue(READER_IDENTIFIER.value())).thenReturn(BigInteger.valueOf(MESSAGE_COUNT));
 		}
 
 		@Test
@@ -83,7 +85,7 @@ public class XtaMessageServiceTest {
 		}
 
 		private XtaMessageMetaDataListing getStatusList() {
-			return service.getStatusList(REQUEST_ID, MAX_LIST_ITEMS);
+			return service.getStatusList(messageMetaDataListingRequest);
 		}
 
 	}