diff --git a/src/main/java/de/ozgcloud/xta/client/XtaClient.java b/src/main/java/de/ozgcloud/xta/client/XtaClient.java index 6cee6c9c4a4bc1df12b79fe1a0adfbdf2f32be59..4307d0fc866c92b436d9c93fc6893808e6ef2119 100644 --- a/src/main/java/de/ozgcloud/xta/client/XtaClient.java +++ b/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(""); } diff --git a/src/main/java/de/ozgcloud/xta/client/XtaClientFactory.java b/src/main/java/de/ozgcloud/xta/client/XtaClientFactory.java index a28ef539f289fc5f291209c2ede55c4336fb4f7e..241815df4e475a81c735ba7e47b40adb8d6d058a 100644 --- a/src/main/java/de/ozgcloud/xta/client/XtaClientFactory.java +++ b/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(); } } diff --git a/src/main/java/de/ozgcloud/xta/client/config/XtaClientConfig.java b/src/main/java/de/ozgcloud/xta/client/config/XtaClientConfig.java index e2b93c3e669712eaeafa796f774ae6cf9bbd8660..1918f5066d532c30e0785c8f23a8f101b64fb585 100644 --- a/src/main/java/de/ozgcloud/xta/client/config/XtaClientConfig.java +++ b/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; diff --git a/src/main/java/de/ozgcloud/xta/client/core/WebServiceTypeMapper.java b/src/main/java/de/ozgcloud/xta/client/core/WebServiceTypeMapper.java index 4a2c29812a943ed6b22073229c295b1e9da3fe20..4c9659dd3d19af5216867393a9c9e97987cd9458 100644 --- a/src/main/java/de/ozgcloud/xta/client/core/WebServiceTypeMapper.java +++ b/src/main/java/de/ozgcloud/xta/client/core/WebServiceTypeMapper.java @@ -1,14 +1,54 @@ 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); + } } diff --git a/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaService.java b/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaService.java index 1a078be9fbbb9e1b19fb87a029bde0f8963c1e9c..09d82e45ae414f58c8d628d0e8482016c14c5872 100644 --- a/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaService.java +++ b/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaService.java @@ -1,9 +1,12 @@ 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 { - service.getManagementPort().checkAccountActive(typeMapper.mapPartyTypeFromIdentifierString(clientIdentifier)); - } catch (XTAWSTechnicalProblemException | PermissionDeniedException e) { - throw new ClientException("checkAccountActive call failed due to: " + e.getMessage(), e); - } + public void checkAccountActive(String clientIdentifier) throws XTAWSTechnicalProblemException, PermissionDeniedException { + service.getManagementPort().checkAccountActive(typeMapper.mapPartyTypeFromIdentifierString(clientIdentifier)); + } + + 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); } } diff --git a/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactory.java b/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactory.java new file mode 100644 index 0000000000000000000000000000000000000000..090c91896ea10652117c762ed64bee0d5e4d4235 --- /dev/null +++ b/src/main/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactory.java @@ -0,0 +1,28 @@ +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(); + } +} diff --git a/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaData.java b/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaData.java index 3f4d0b8742382a504a03296ea23716af6730f09b..80f87a24032c615b8e544de8495174f302086a13 100644 --- a/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaData.java +++ b/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaData.java @@ -1,20 +1,10 @@ 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 +) { } diff --git a/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDataAndHeader.java b/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDataAndHeader.java new file mode 100644 index 0000000000000000000000000000000000000000..86fcfa347815f1a42eb220f41172a9493aec07d9 --- /dev/null +++ b/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDataAndHeader.java @@ -0,0 +1,13 @@ +package de.ozgcloud.xta.client.model; + +import java.util.List; + +import lombok.Builder; + +@Builder +public record XtaMessageMetaDataAndHeader( + String msgBoxRequestID, + boolean moreMessagesAvailable, + List<XtaMessageMetaData> messages +) { +} diff --git a/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDatasAndHeader.java b/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDatasAndHeader.java deleted file mode 100644 index 6a14f2d12525dfd11a64c92669e87e0b4c278f9f..0000000000000000000000000000000000000000 --- a/src/main/java/de/ozgcloud/xta/client/model/XtaMessageMetaDatasAndHeader.java +++ /dev/null @@ -1,10 +0,0 @@ -package de.ozgcloud.xta.client.model; - -import java.util.stream.Stream; - -public class XtaMessageMetaDatasAndHeader { - - private String msgBoxRequestID; - private boolean moreMessagesAvailable; - private Stream<XtaMessageMetaData> messages; -} diff --git a/src/test/java/de/ozgcloud/xta/client/XtaClientConfigTestFactory.java b/src/test/java/de/ozgcloud/xta/client/XtaClientConfigTestFactory.java index feceef55fbf2162712f7d04a89c3ddd743a8bb72..9be6dc7caad67fc601d097929cf6c50d5fab708c 100644 --- a/src/test/java/de/ozgcloud/xta/client/XtaClientConfigTestFactory.java +++ b/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); diff --git a/src/test/java/de/ozgcloud/xta/client/XtaClientFactoryTest.java b/src/test/java/de/ozgcloud/xta/client/XtaClientFactoryTest.java index 4ddc2fbfab6f9d6dd3a0fb5c5ac64479a1461e43..8ae78c44c0d67e6e9bb0fb1770d122ed55f99b9e 100644 --- a/src/test/java/de/ozgcloud/xta/client/XtaClientFactoryTest.java +++ b/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") diff --git a/src/test/java/de/ozgcloud/xta/client/XtaClientTest.java b/src/test/java/de/ozgcloud/xta/client/XtaClientTest.java index abac4619bcbfbe7c28f3c4422ff76dd19d708e9a..3eb0d1401b89503dc7d800668f55f9d5b262fd01 100644 --- a/src/test/java/de/ozgcloud/xta/client/XtaClientTest.java +++ b/src/test/java/de/ozgcloud/xta/client/XtaClientTest.java @@ -1,8 +1,10 @@ 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 diff --git a/src/test/java/de/ozgcloud/xta/client/config/XtaConfigValidatorTest.java b/src/test/java/de/ozgcloud/xta/client/config/XtaConfigValidatorTest.java index a06f8a619c962670170fdd28ae5884e1d3668b52..c1d2c496e7f88c98be3ad7c2d2bb07aa75e764b6 100644 --- a/src/test/java/de/ozgcloud/xta/client/config/XtaConfigValidatorTest.java +++ b/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 { diff --git a/src/test/java/de/ozgcloud/xta/client/core/MessageMetaDataTestFactory.java b/src/test/java/de/ozgcloud/xta/client/core/MessageMetaDataTestFactory.java new file mode 100644 index 0000000000000000000000000000000000000000..14d264c1c14ce1a1549ddb4a654f5872f90d5d35 --- /dev/null +++ b/src/test/java/de/ozgcloud/xta/client/core/MessageMetaDataTestFactory.java @@ -0,0 +1,38 @@ +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; + } +} diff --git a/src/test/java/de/ozgcloud/xta/client/core/MsgBoxResponseTypeTestFactory.java b/src/test/java/de/ozgcloud/xta/client/core/MsgBoxResponseTypeTestFactory.java new file mode 100644 index 0000000000000000000000000000000000000000..85eab3df7a0a5fa248642c051bc10f5053a20dc9 --- /dev/null +++ b/src/test/java/de/ozgcloud/xta/client/core/MsgBoxResponseTypeTestFactory.java @@ -0,0 +1,30 @@ +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; + } +} diff --git a/src/test/java/de/ozgcloud/xta/client/core/MsgStatusListTypeTestFactory.java b/src/test/java/de/ozgcloud/xta/client/core/MsgStatusListTypeTestFactory.java new file mode 100644 index 0000000000000000000000000000000000000000..c614c02ed191969a922c65dc346dd457328e2b46 --- /dev/null +++ b/src/test/java/de/ozgcloud/xta/client/core/MsgStatusListTypeTestFactory.java @@ -0,0 +1,23 @@ +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; + } +} diff --git a/src/test/java/de/ozgcloud/xta/client/core/WebServiceTypeMapperTest.java b/src/test/java/de/ozgcloud/xta/client/core/WebServiceTypeMapperTest.java index 064e8e953f7ba0d9cd57c63b5f90e880a774de37..b4187152d4f5170a8a0b150a13c8b6413ac1f7c9 100644 --- a/src/test/java/de/ozgcloud/xta/client/core/WebServiceTypeMapperTest.java +++ b/src/test/java/de/ozgcloud/xta/client/core/WebServiceTypeMapperTest.java @@ -1,8 +1,11 @@ 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 diff --git a/src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactoryTest.java b/src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactoryTest.java new file mode 100644 index 0000000000000000000000000000000000000000..d6eec9bae0b5e5396d1fe567ffd299af967612d6 --- /dev/null +++ b/src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceFactoryTest.java @@ -0,0 +1,63 @@ +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 diff --git a/src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceTest.java b/src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceTest.java index a2bd9eae053ac1c47a98df8ad32a8b30e405d03e..10e58ead107715e7742a80094fa7f1d317dabebd 100644 --- a/src/test/java/de/ozgcloud/xta/client/core/WrappedXtaServiceTest.java +++ b/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); } }