KOP-2139 KOP-2445 getStatusList: Map request and response data

src/main/java/de/ozgcloud/xta/client/XtaClient.java

@@ -4,10 +4,11 @@ import org.apache.commons.lang3.NotImplementedException;
 
 import de.ozgcloud.xta.client.config.XtaClientConfig;
 import de.ozgcloud.xta.client.core.WrappedXtaService;
-import de.ozgcloud.xta.client.exception.ClientException;
 import de.ozgcloud.xta.client.model.XtaMessage;
 import de.ozgcloud.xta.client.model.XtaMessageId;
-import de.ozgcloud.xta.client.model.XtaMessageMetaDatasAndHeader;
+import de.ozgcloud.xta.client.model.XtaMessageMetaDataAndHeader;
+import genv3.de.xoev.transport.xta.x211.PermissionDeniedException;
+import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Getter;
@@ -21,12 +22,13 @@ public class XtaClient {
 	private final WrappedXtaService service;
 	private final XtaClientConfig config;
 
-	public XtaMessageMetaDatasAndHeader getMessagesMetadata(String xtaIdentifier) throws ClientException {
+	public XtaMessageMetaDataAndHeader getMessagesMetadata(String xtaIdentifier)
+			throws XTAWSTechnicalProblemException, PermissionDeniedException {
 		service.checkAccountActive(xtaIdentifier);
-		return null;
+		return service.getStatusList(xtaIdentifier, config.getMaxListItems());
 	}
 
-	public XtaMessageMetaDatasAndHeader getNextMessagesMetadata(String xtaIdentifier, String msgBoxRequestId) {
+	public XtaMessageMetaDataAndHeader getNextMessagesMetadata(String xtaIdentifier, String msgBoxRequestId) {
 		throw new NotImplementedException("");
 	}
 

src/main/java/de/ozgcloud/xta/client/XtaClientFactory.java

@@ -2,8 +2,7 @@ package de.ozgcloud.xta.client;
 
 import de.ozgcloud.xta.client.config.XtaClientConfig;
 import de.ozgcloud.xta.client.config.XtaConfigValidator;
-import de.ozgcloud.xta.client.core.WrappedXtaService;
-import de.ozgcloud.xta.client.core.XTAServiceFactory;
+import de.ozgcloud.xta.client.core.WrappedXtaServiceFactory;
 import de.ozgcloud.xta.client.exception.ClientInitializationException;
 import lombok.Builder;
 import lombok.RequiredArgsConstructor;
@@ -13,13 +12,13 @@ import lombok.RequiredArgsConstructor;
 public class XtaClientFactory {
 
 	private final XtaConfigValidator configValidator;
-	private final XTAServiceFactory xtaServiceFactory;
+	private final WrappedXtaServiceFactory wrappedXtaServiceFactory;
 	private final XtaClientConfig config;
 
 	public static XtaClientFactory from(final XtaClientConfig config) {
 		return XtaClientFactory.builder()
 				.configValidator(XtaConfigValidator.builder().build())
-				.xtaServiceFactory(XTAServiceFactory.from(config))
+				.wrappedXtaServiceFactory(WrappedXtaServiceFactory.from(config))
 				.build();
 	}
 
@@ -27,9 +26,7 @@ public class XtaClientFactory {
 		configValidator.validate(config);
 		return XtaClient.builder()
 				.config(config)
-				.service(WrappedXtaService.builder()
-						.service(xtaServiceFactory.create())
-						.build())
+				.service(wrappedXtaServiceFactory.create())
 				.build();
 	}
 }

src/main/java/de/ozgcloud/xta/client/config/XtaClientConfig.java

@@ -17,6 +17,7 @@ import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotEmpty;
 import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
 
 import lombok.Builder;
 import lombok.Getter;
@@ -39,6 +40,9 @@ public class XtaClientConfig {
 	@NotBlank
 	private final String msgBoxServiceUrl;
 
+	@Positive
+	private final int maxListItems;
+
 	@Valid
 	private final KeyStore clientCertKeystore;
 

src/main/java/de/ozgcloud/xta/client/core/WebServiceTypeMapper.java

 package de.ozgcloud.xta.client.core;
 
+import java.math.BigInteger;
+import java.util.Optional;
+
 import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.Named;
+import org.mapstruct.ReportingPolicy;
 
+import de.ozgcloud.xta.client.model.XtaMessageMetaData;
+import de.ozgcloud.xta.client.model.XtaMessageMetaDataAndHeader;
+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.MsgStatusListType;
+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;
 
-@Mapper
+@Mapper(
+		unmappedTargetPolicy = ReportingPolicy.ERROR
+)
 public interface WebServiceTypeMapper {
 
+	String IDENTIFIER_CATEGORY = "xoev";
+
+	@Mapping(target = "securityToken", ignore = true)
 	PartyType mapPartyTypeFromIdentifierString(String identifier);
 
+	@Mapping(target = "type", ignore = true)
+	@Mapping(target = "name", ignore = true)
+	@Mapping(target = "category", constant = IDENTIFIER_CATEGORY)
 	PartyIdentifierType mapPartyIdentifierTypeFromIdentifierString(String value);
+
+	@Mapping(target = "maxListItems", source = "maxListItems")
+	@Mapping(target = "listForm", constant = "MessageMetaData")
+	@Mapping(target = "msgSelector", ignore = true)
+	MsgBoxStatusListRequestType mapMsgBoxStatusListRequestTypeFromMaxListItems(Integer maxListItems);
+
+	@Mapping(target = "moreMessagesAvailable", source = "response", qualifiedByName = "mapMoreMessagesAvailable")
+	@Mapping(target = "messages", source = "msgStatusListType.messageMetaData")
+	XtaMessageMetaDataAndHeader mapXtaMessageMetaDataAndHeader(MsgStatusListType msgStatusListType, MsgBoxResponseType response);
+
+	@Mapping(target = "messageId", source = "msgIdentification.messageID.value")
+	@Mapping(target = "messageType", source = "qualifier.messageType.code")
+	XtaMessageMetaData mapXtaMessageMetaData(MessageMetaData messageMetaData);
+
+	@Named("mapMoreMessagesAvailable")
+	default boolean mapMoreMessagesAvailable(MsgBoxResponseType response) {
+		return Optional.ofNullable(response.getItemsPending())
+				.map(messagesPending -> !BigInteger.ZERO.equals(messagesPending))
+				.orElse(false);
+	}
 }

src/main/java/de/ozgcloud/xta/client/core/WrappedXtaService.java

 package de.ozgcloud.xta.client.core;
 
-import de.ozgcloud.xta.client.exception.ClientException;
+import jakarta.xml.ws.Holder;
+
+import de.ozgcloud.xta.client.model.XtaMessageMetaDataAndHeader;
 import genv3.de.xoev.transport.xta.x211.PermissionDeniedException;
 import genv3.de.xoev.transport.xta.x211.XTAService;
 import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
+import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxResponseType;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -16,12 +19,19 @@ public class WrappedXtaService {
 	private final XTAService service;
 	private final WebServiceTypeMapper typeMapper;
 
-	public void checkAccountActive(String clientIdentifier) throws ClientException {
-		try {
+	public void checkAccountActive(String clientIdentifier) throws XTAWSTechnicalProblemException, PermissionDeniedException {
 		service.getManagementPort().checkAccountActive(typeMapper.mapPartyTypeFromIdentifierString(clientIdentifier));
-		} catch (XTAWSTechnicalProblemException | PermissionDeniedException e) {
-			throw new ClientException("checkAccountActive call failed due to: " + e.getMessage(), e);
 	}
+
+	public XtaMessageMetaDataAndHeader getStatusList(String clientIdentifier, int maxListItems)
+			throws XTAWSTechnicalProblemException, PermissionDeniedException {
+		final Holder<MsgBoxResponseType> fetchResponseHeader = new Holder<>();
+		var msgStatusListType = service.getMsgBoxPort().getStatusList(
+				typeMapper.mapMsgBoxStatusListRequestTypeFromMaxListItems(maxListItems),
+				typeMapper.mapPartyTypeFromIdentifierString(clientIdentifier),
+				fetchResponseHeader
+		);
+		return typeMapper.mapXtaMessageMetaDataAndHeader(msgStatusListType, fetchResponseHeader.value);
 	}
 
 }

src/main/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactory.java

+package de.ozgcloud.xta.client.core;
+
+import de.ozgcloud.xta.client.config.XtaClientConfig;
+import de.ozgcloud.xta.client.exception.ClientInitializationException;
+import lombok.Builder;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Builder
+public class WrappedXtaServiceFactory {
+
+	private final XTAServiceFactory xtaServiceFactory;
+	private final WebServiceTypeMapper typeMapper;
+
+	public static WrappedXtaServiceFactory from(final XtaClientConfig config) {
+		return WrappedXtaServiceFactory.builder()
+				.xtaServiceFactory(XTAServiceFactory.from(config))
+				.typeMapper(new WebServiceTypeMapperImpl())
+				.build();
+	}
+
+	public WrappedXtaService create() throws ClientInitializationException {
+		return WrappedXtaService.builder()
+				.service(xtaServiceFactory.create())
+				.typeMapper(typeMapper)
+				.build();
+	}
+}

src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaData.java

 package de.ozgcloud.xta.client.model;
 
-import java.time.ZonedDateTime;
-
 import lombok.Builder;
-import lombok.Getter;
 
 @Builder
-@Getter
-class XtaMessageMetaData {
-	// MsgIdentification.MessageId
-	private XtaMessageId messageId;
-	// DeliveryAttributes.origin
-	private ZonedDateTime origin;
-	// DeliveryAttributes.delivery
-	private ZonedDateTime delivery;
-	// Qualifier.MessageType.code
-	private String messageType;
-
+public record XtaMessageMetaData(
+		String messageId,
+		String messageType
+) {
 }

src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDataAndHeader.java

+package de.ozgcloud.xta.client.model;
+
+import java.util.List;
+
+import lombok.Builder;
+
+@Builder
+public record XtaMessageMetaDataAndHeader(
+		String msgBoxRequestID,
+		boolean moreMessagesAvailable,
+		List<XtaMessageMetaData> messages
+) {
+}

src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDatasAndHeader.java

-package de.ozgcloud.xta.client.model;
-
-import java.util.stream.Stream;
-
-public class XtaMessageMetaDatasAndHeader {
-
-	private String msgBoxRequestID;
-	private boolean moreMessagesAvailable;
-	private Stream<XtaMessageMetaData> messages;
-}

src/test/java/de/ozgcloud/xta/client/XtaClientConfigTestFactory.java

@@ -21,6 +21,7 @@ import lombok.SneakyThrows;
 public class XtaClientConfigTestFactory {
 
 	public static final String SELF_IDENTIFIER = "selfIdentifier";
+	public static final int MAX_LIST_ITEMS = 10;
 	static final String SELF_IDENTIFIER2 = "selfIdentifier2";
 
 	public static final String KEYSTORE_ALIAS = "selfSigned";
@@ -45,6 +46,7 @@ public class XtaClientConfigTestFactory {
 				.sendServiceUrl(SEND_PORT_SVC)
 				.msgBoxServiceUrl(MSG_BOX_PORT_SVC)
 				.clientIdentifiers(List.of(SELF_IDENTIFIER, SELF_IDENTIFIER2))
+				.maxListItems(MAX_LIST_ITEMS)
 				.logSoapRequests(true)
 				.logSoapResponses(true)
 				.schemaValidation(true);

src/test/java/de/ozgcloud/xta/client/XtaClientFactoryTest.java

@@ -14,8 +14,8 @@ import org.mockito.junit.jupiter.MockitoExtension;
 
 import de.ozgcloud.xta.client.config.XtaClientConfig;
 import de.ozgcloud.xta.client.config.XtaConfigValidator;
-import de.ozgcloud.xta.client.core.XTAServiceFactory;
-import genv3.de.xoev.transport.xta.x211.XTAService;
+import de.ozgcloud.xta.client.core.WrappedXtaService;
+import de.ozgcloud.xta.client.core.WrappedXtaServiceFactory;
 import lombok.SneakyThrows;
 
 @ExtendWith(MockitoExtension.class)
@@ -24,7 +24,7 @@ class XtaClientFactoryTest {
 	@Mock
 	private XtaConfigValidator configValidator;
 	@Mock
-	private XTAServiceFactory xtaServiceFactory;
+	private WrappedXtaServiceFactory wrappedXtaServiceFactory;
 	@Mock
 	private XtaClientConfig config;
 
@@ -36,12 +36,12 @@ class XtaClientFactoryTest {
 	class TestCreate {
 
 		@Mock
-		private XTAService service;
+		private WrappedXtaService service;
 
 		@BeforeEach
 		@SneakyThrows
 		void mock() {
-			when(xtaServiceFactory.create()).thenReturn(service);
+			when(wrappedXtaServiceFactory.create()).thenReturn(service);
 		}
 
 		@DisplayName("should have service")
@@ -50,7 +50,7 @@ class XtaClientFactoryTest {
 		void shouldHaveService() {
 			var client = factory.create();
 
-			assertThat(client.getService().getService()).isEqualTo(service);
+			assertThat(client.getService()).isEqualTo(service);
 		}
 
 		@DisplayName("should have config")

src/test/java/de/ozgcloud/xta/client/XtaClientTest.java

 package de.ozgcloud.xta.client;
 
 import static de.ozgcloud.xta.client.XtaClientConfigTestFactory.*;
+import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -13,6 +15,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
 
 import de.ozgcloud.xta.client.config.XtaClientConfig;
 import de.ozgcloud.xta.client.core.WrappedXtaService;
+import de.ozgcloud.xta.client.model.XtaMessageMetaDataAndHeader;
 import lombok.SneakyThrows;
 
 @ExtendWith(MockitoExtension.class)
@@ -31,6 +34,16 @@ class XtaClientTest {
 	@Nested
 	class TestGetMessagesMetadata {
 
+		@Mock
+		XtaMessageMetaDataAndHeader xtaMessageMetaDataAndHeader;
+
+		@BeforeEach
+		@SneakyThrows
+		void mock() {
+			when(service.getStatusList(SELF_IDENTIFIER, MAX_LIST_ITEMS)).thenReturn(xtaMessageMetaDataAndHeader);
+			when(config.getMaxListItems()).thenReturn(MAX_LIST_ITEMS);
+		}
+
 		@DisplayName("should call checkAccountActive")
 		@Test
 		@SneakyThrows
@@ -40,6 +53,15 @@ class XtaClientTest {
 			verify(service).checkAccountActive(SELF_IDENTIFIER);
 		}
 
+		@DisplayName("should return get status list response")
+		@Test
+		@SneakyThrows
+		void shouldReturnGetStatusListResponse() {
+			var result = client.getMessagesMetadata(SELF_IDENTIFIER);
+
+			assertThat(result).isEqualTo(xtaMessageMetaDataAndHeader);
+		}
+
 	}
 
 }
\ No newline at end of file

src/test/java/de/ozgcloud/xta/client/config/XtaConfigValidatorTest.java

@@ -94,6 +94,18 @@ class XtaConfigValidatorTest {
 					.hasMessageContaining("msgBoxServiceUrl");
 		}
 
+		@DisplayName("should throw with non-positive max list items")
+		@Test
+		void shouldThrowWithNonPositiveMaxListItems() {
+			var config = XtaClientConfigTestFactory.createBuilder()
+					.maxListItems(0)
+					.build();
+
+			assertThatThrownBy(() -> validator.validate(config))
+					.isInstanceOf(ClientInitializationException.class)
+					.hasMessageContaining("maxListItems");
+		}
+
 		@DisplayName("with invalid client cert keystore")
 		@Nested
 		class TestWithInvalidClientCertKeystore {

src/test/java/de/ozgcloud/xta/client/core/MessageMetaDataTestFactory.java

+package de.ozgcloud.xta.client.core;
+
+import java.math.BigInteger;
+
+import org.apache.cxf.ws.addressing.AttributedURIType;
+
+import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
+
+public class MessageMetaDataTestFactory {
+
+	public static final String MESSAGE_ID = "messageId1";
+	public static final String MESSAGE_ID2 = "messageId2";
+	public static final String MESSAGE_ID3 = "messageId3";
+
+	public static final String MESSAGE_TYPE = "messageType";
+	public static final String MESSAGE_TYPE2 = "messageType2";
+	public static final String MESSAGE_TYPE3 = "messageType3";
+
+	public static final BigInteger MESSAGE_SIZE = BigInteger.valueOf(1234);
+
+	public static MessageMetaData create() {
+		return create(MESSAGE_ID, MESSAGE_TYPE, MESSAGE_SIZE);
+	}
+
+	public static MessageMetaData create(String messageId, String messageType, BigInteger messageSize) {
+		var messageMetaData = new MessageMetaData();
+
+		var messageIdType = new AttributedURIType();
+		messageIdType.setValue(messageId);
+		messageMetaData.getMsgIdentification().setMessageID(messageIdType);
+
+		messageMetaData.getQualifier().getMessageType().setCode(messageType);
+
+		messageMetaData.setMsgSize(messageSize);
+
+		return messageMetaData;
+	}
+}

src/test/java/de/ozgcloud/xta/client/core/MsgBoxResponseTypeTestFactory.java

+package de.ozgcloud.xta.client.core;
+
+import java.math.BigInteger;
+
+import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxResponseType;
+
+public class MsgBoxResponseTypeTestFactory {
+	public static final String MSG_BOX_REQUEST_ID = "msgBoxRequestId1";
+	public static final BigInteger ITEMS_PENDING = BigInteger.valueOf(5);
+
+	public static MsgBoxResponseType create() {
+		var msgBoxResponseType = new MsgBoxResponseType();
+		msgBoxResponseType.setMsgBoxRequestID(MSG_BOX_REQUEST_ID);
+		return msgBoxResponseType;
+	}
+
+	public static MsgBoxResponseType createWithPendingMessages() {
+		var msgBoxResponseType = create();
+		msgBoxResponseType.setItemsPending(ITEMS_PENDING);
+		msgBoxResponseType.setNoMessageAvailable(null);
+		return msgBoxResponseType;
+	}
+
+	public static MsgBoxResponseType createWithNoPendingMessages() {
+		var msgBoxResponseType = create();
+		msgBoxResponseType.setItemsPending(null);
+		msgBoxResponseType.setNoMessageAvailable(new MsgBoxResponseType.NoMessageAvailable());
+		return msgBoxResponseType;
+	}
+}

src/test/java/de/ozgcloud/xta/client/core/MsgStatusListTypeTestFactory.java

+package de.ozgcloud.xta.client.core;
+
+import static de.ozgcloud.xta.client.core.MessageMetaDataTestFactory.*;
+
+import java.util.List;
+
+import genv3.eu.osci.ws.x2008.x05.transport.MsgStatusListType;
+import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
+
+public class MsgStatusListTypeTestFactory {
+
+	public static List<MessageMetaData> MESSAGE_META_DATA_LIST = List.of(
+			MessageMetaDataTestFactory.create(),
+			MessageMetaDataTestFactory.create(MESSAGE_ID2, MESSAGE_TYPE2, MESSAGE_SIZE),
+			MessageMetaDataTestFactory.create(MESSAGE_ID3, MESSAGE_TYPE3, MESSAGE_SIZE)
+	);
+
+	public static MsgStatusListType create() {
+		var msgStatusListType = new MsgStatusListType();
+		msgStatusListType.getMessageMetaData().addAll(MESSAGE_META_DATA_LIST);
+		return msgStatusListType;
+	}
+}

src/test/java/de/ozgcloud/xta/client/core/WebServiceTypeMapperTest.java

 package de.ozgcloud.xta.client.core;
 
 import static de.ozgcloud.xta.client.XtaClientConfigTestFactory.*;
+import static de.ozgcloud.xta.client.core.MessageMetaDataTestFactory.*;
+import static de.ozgcloud.xta.client.core.WebServiceTypeMapper.*;
 import static org.assertj.core.api.Assertions.*;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -10,6 +13,10 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import de.ozgcloud.xta.client.model.XtaMessageMetaData;
+import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxResponseType;
+import genv3.eu.osci.ws.x2008.x05.transport.MsgStatusListType;
+
 @ExtendWith(MockitoExtension.class)
 class WebServiceTypeMapperTest {
 
@@ -20,13 +27,94 @@ class WebServiceTypeMapperTest {
 	@Nested
 	class TestMapPartyTypeFromIdentifierString {
 
-		@DisplayName("should map party type from identifier string")
+		@DisplayName("should use identifier")
 		@Test
-		void shouldMapPartyTypeFromIdentifierString() {
+		void shouldUseIdentifier() {
 			var result = mapper.mapPartyTypeFromIdentifierString(SELF_IDENTIFIER);
 
 			assertThat(result.getIdentifier().getValue()).isEqualTo(SELF_IDENTIFIER);
 		}
+
+		@DisplayName("should use xoev category")
+		@Test
+		void shouldUseXoevCategory() {
+			var result = mapper.mapPartyTypeFromIdentifierString(SELF_IDENTIFIER);
+
+			assertThat(result.getIdentifier().getCategory()).isEqualTo(IDENTIFIER_CATEGORY);
+		}
+	}
+
+	@DisplayName("map msg box status list request from max list items")
+	@Nested
+	class TestMapMsgBoxStatusListRequestFromMaxListItems {
+
+		@DisplayName("should use max list items")
+		@Test
+		void shouldUseMaxListItems() {
+			var result = mapper.mapMsgBoxStatusListRequestTypeFromMaxListItems(MAX_LIST_ITEMS);
+
+			assertThat(result.getMaxListItems().intValue()).isEqualTo(MAX_LIST_ITEMS);
+		}
+	}
+
+	@DisplayName("map xta message meta data and header")
+	@Nested
+	class TestMapXtaMessageMetaDataAndHeader {
+
+		private MsgStatusListType msgStatusListType;
+		private MsgBoxResponseType msgBoxResponseTypeWithPendingMessages;
+		private MsgBoxResponseType msgBoxResponseTypeWithNoPendingMessages;
+
+		@BeforeEach
+		void setup() {
+			msgStatusListType = MsgStatusListTypeTestFactory.create();
+			msgBoxResponseTypeWithPendingMessages = MsgBoxResponseTypeTestFactory
+					.createWithPendingMessages();
+			msgBoxResponseTypeWithNoPendingMessages = MsgBoxResponseTypeTestFactory
+					.createWithNoPendingMessages();
+		}
+
+		@DisplayName("should map more messages available to true with pending messages")
+		@Test
+		void shouldMapMoreMessagesAvailableToTrueWithPendingMessages() {
+			var result = mapper.mapXtaMessageMetaDataAndHeader(
+					msgStatusListType, msgBoxResponseTypeWithPendingMessages);
+
+			assertThat(result.moreMessagesAvailable()).isTrue();
+		}
+
+		@DisplayName("should map more messages to false with no pending messages")
+		@Test
+		void shouldMapMoreMessagesToFalseWithNoPendingMessages() {
+			var result = mapper.mapXtaMessageMetaDataAndHeader(
+					msgStatusListType, msgBoxResponseTypeWithNoPendingMessages);
+
+			assertThat(result.moreMessagesAvailable()).isFalse();
+		}
+
+		@DisplayName("should map message id")
+		@Test
+		void shouldMapMessageId() {
+			var result = mapper.mapXtaMessageMetaDataAndHeader(
+					msgStatusListType, msgBoxResponseTypeWithPendingMessages);
+
+			var messageIds = result.messages().stream()
+					.map(XtaMessageMetaData::messageId)
+					.toList();
+			assertThat(messageIds).containsExactly(MESSAGE_ID, MESSAGE_ID2, MESSAGE_ID3);
+		}
+
+		@DisplayName("should map message type")
+		@Test
+		void shouldMapMessageType() {
+			var result = mapper.mapXtaMessageMetaDataAndHeader(
+					msgStatusListType, msgBoxResponseTypeWithPendingMessages);
+
+			var messageTypes = result.messages().stream()
+					.map(XtaMessageMetaData::messageType)
+					.toList();
+			assertThat(messageTypes).containsExactly(MESSAGE_TYPE, MESSAGE_TYPE2, MESSAGE_TYPE3);
+		}
 	}
 
 }
\ No newline at end of file

src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactoryTest.java

+package de.ozgcloud.xta.client.core;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+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.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import de.ozgcloud.xta.client.config.XtaClientConfig;
+import genv3.de.xoev.transport.xta.x211.XTAService;
+import lombok.SneakyThrows;
+
+@ExtendWith(MockitoExtension.class)
+class WrappedXtaServiceFactoryTest {
+
+	@Mock
+	private XTAServiceFactory xtaServiceFactory;
+	@Mock
+	private WebServiceTypeMapper typeMapper;
+	@Mock
+	private XtaClientConfig config;
+
+	@InjectMocks
+	private WrappedXtaServiceFactory factory;
+
+	@DisplayName("create")
+	@Nested
+	class TestCreate {
+
+		@Mock
+		private XTAService service;
+
+		@BeforeEach
+		@SneakyThrows
+		void mock() {
+			when(xtaServiceFactory.create()).thenReturn(service);
+		}
+
+		@DisplayName("should have service")
+		@Test
+		@SneakyThrows
+		void shouldHaveService() {
+			var wrappedService = factory.create();
+
+			assertThat(wrappedService.getService()).isEqualTo(service);
+		}
+
+		@DisplayName("should have type mapper")
+		@Test
+		@SneakyThrows
+		void shouldHaveTypeMapper() {
+			var wrappedService = factory.create();
+
+			assertThat(wrappedService.getTypeMapper()).isEqualTo(typeMapper);
+		}
+	}
+}
\ No newline at end of file

src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceTest.java

@@ -4,6 +4,8 @@ import static de.ozgcloud.xta.client.XtaClientConfigTestFactory.*;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import jakarta.xml.ws.Holder;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -13,10 +15,13 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import de.ozgcloud.xta.client.exception.ClientException;
+import de.ozgcloud.xta.client.model.XtaMessageMetaDataAndHeader;
 import genv3.de.xoev.transport.xta.x211.ManagementPortType;
+import genv3.de.xoev.transport.xta.x211.MsgBoxPortType;
 import genv3.de.xoev.transport.xta.x211.XTAService;
-import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
+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.MsgStatusListType;
 import genv3.eu.osci.ws.x2014.x10.transport.PartyType;
 import lombok.SneakyThrows;
 
@@ -56,17 +61,54 @@ class WrappedXtaServiceTest {
 
 			verify(managementPortType).checkAccountActive(partyType);
 		}
+	}
+
+	@DisplayName("get status list")
+	@Nested
+	class TestGetStatusList {
+		@Mock
+		private MsgBoxPortType msgBoxPortType;
+
+		@Mock
+		private MsgBoxStatusListRequestType msgBoxStatusListRequestType;
+
+		@Mock
+		private PartyType partyType;
+
+		@Mock
+		private MsgBoxResponseType msgBoxResponseType;
+
+		@Mock
+		private MsgStatusListType msgStatusListType;
+
+		@Mock
+		private XtaMessageMetaDataAndHeader xtaMessageMetaDataAndHeader;
+
+		@BeforeEach
+		@SneakyThrows
+		void mock() {
+			when(rawService.getMsgBoxPort()).thenReturn(msgBoxPortType);
+			when(typeMapper.mapPartyTypeFromIdentifierString(SELF_IDENTIFIER)).thenReturn(partyType);
+			when(typeMapper.mapMsgBoxStatusListRequestTypeFromMaxListItems(MAX_LIST_ITEMS))
+					.thenReturn(msgBoxStatusListRequestType);
+			when(msgBoxPortType.getStatusList(eq(msgBoxStatusListRequestType), eq(partyType), any()))
+					.thenAnswer(invocation -> {
+						@SuppressWarnings("unchecked")
+						var responseType = (Holder<MsgBoxResponseType>) invocation.getArgument(2);
+						responseType.value = msgBoxResponseType;
+						return msgStatusListType;
+					});
+			when(typeMapper.mapXtaMessageMetaDataAndHeader(msgStatusListType, msgBoxResponseType))
+					.thenReturn(xtaMessageMetaDataAndHeader);
+		}
 
-		@DisplayName("should throw client exception on technical problem")
+		@DisplayName("should map response")
 		@Test
 		@SneakyThrows
-		void shouldThrowClientExceptionOnTechnicalProblem() {
-			var message = "technical problem";
-			doThrow(new XTAWSTechnicalProblemException(message)).when(managementPortType).checkAccountActive(partyType);
+		void shouldMapResponse() {
+			var result = service.getStatusList(SELF_IDENTIFIER, MAX_LIST_ITEMS);
 
-			assertThatThrownBy(() -> service.checkAccountActive(SELF_IDENTIFIER))
-					.isInstanceOf(ClientException.class)
-					.hasMessageContaining(message);
+			assertThat(result).isEqualTo(xtaMessageMetaDataAndHeader);
 		}
 	}