Skip to content
Snippets Groups Projects
Commit d7e81766 authored by Jan Zickermann's avatar Jan Zickermann
Browse files

OZG-6239 Create XtaCloseRequest class and adjust to merge issues

parent 17b9761e
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 678 additions and 433 deletions
src/main/java/de/ozgcloud/xta/test/app/data/XtaMessageRepository.java
+ 7
− 0
View file @ d7e81766
......@@ -64,4 +64,11 @@ public class XtaMessageRepository {
return messages.values().stream()
.filter(m -> m.metaData().readerIdentifier().value().equals(readerIdentifierValue));
}
public boolean deleteByMessageIdAndReaderIdentifierValue(String messageId, String readerIdentifierValue) {
return get(messageId)
.filter(m -> m.metaData().readerIdentifier().value().equals(readerIdentifierValue))
.map(m -> delete(messageId))
.orElse(false);
}
}
src/main/java/de/ozgcloud/xta/test/app/mapper/ExceptionMapper.java 0 → 100644
+ 43
− 0
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import static de.ozgcloud.xta.test.app.model.XtaConstants.*;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.ReportingPolicy;
import genv3.de.xoev.transport.xta.x211.CodeFehlernummer;
import genv3.de.xoev.transport.xta.x211.InvalidMessageIDException;
import genv3.de.xoev.transport.xta.x211.InvalidMessageIDExceptionType;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemExceptionType;
@Mapper(
unmappedTargetPolicy = ReportingPolicy.ERROR
)
public interface ExceptionMapper {
default InvalidMessageIDException createInvalidMessageIDException(String message) {
return new InvalidMessageIDException(
message,
mapInvalidMessageIDExceptionType(ERROR_CODE_MESSAGE_ID_UNKNOWN, ERROR_CODE_MESSAGE_ID_UNKNOWN_DESCRIPTION)
);
}
@Mapping(target = "errorCode", expression = "java( mapCodeFehlernummer(code, name) )")
InvalidMessageIDExceptionType mapInvalidMessageIDExceptionType(String code, String name);
default XTAWSTechnicalProblemException createTechnicalProblemException(String message) {
return new XTAWSTechnicalProblemException(
message,
mapXTAWSTechnicalProblemExceptionType(ERROR_CODE_INTERNAL_TECHNICAL_PROBLEM, ERROR_CODE_INTERNAL_TECHNICAL_PROBLEM_DESCRIPTION)
);
}
@Mapping(target = "errorCode", expression = "java( mapCodeFehlernummer(code, name) )")
XTAWSTechnicalProblemExceptionType mapXTAWSTechnicalProblemExceptionType(String code, String name);
@Mapping(target = "listURI", constant = ERROR_CODE_LIST_URN)
@Mapping(target = "listVersionID", constant = ERROR_CODE_LIST_VERSION)
CodeFehlernummer mapCodeFehlernummer(String code, String name);
}
src/main/java/de/ozgcloud/xta/test/app/mapper/RequestMapper.java
+ 23
− 27
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import jakarta.activation.DataHandler;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Named;
import org.mapstruct.ReportingPolicy;
import de.ozgcloud.xta.test.app.exception.TechnicalException;
import de.ozgcloud.xta.test.app.model.Identifier;
import de.ozgcloud.xta.test.app.model.XtaCloseRequest;
import de.ozgcloud.xta.test.app.model.XtaFile;
import de.ozgcloud.xta.test.app.model.XtaGetMessageRequest;
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.MsgBoxCloseRequestType;
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;
import java.io.FileOutputStream;
import java.io.IOException;
@Mapper(
unmappedTargetPolicy = ReportingPolicy.ERROR
)
......@@ -76,20 +77,15 @@ public interface RequestMapper {
return fetchRequest.getMsgSelector().getMessageID().getFirst().getValue();
}
default int mapMaxListItems(MsgBoxStatusListRequestType fetchRequest) {
int maxListItems;
try {
maxListItems = fetchRequest.getMaxListItems().intValueExact();
} catch (ArithmeticException e) {
maxListItems = Integer.MAX_VALUE;
}
if (maxListItems <= 0) {
maxListItems = Integer.MAX_VALUE;
}
return maxListItems;
}
@Mapping(target = "clientIdentifierValue", source = "clientIdentifier.identifier.value")
@Mapping(target = "maxListItems", source = "fetchRequest.maxListItems")
XtaMessageMetaDataListingRequest mapMessageMetaDataListingRequest(MsgBoxStatusListRequestType fetchRequest, PartyType clientIdentifier);
@Mapping(target = "messageId", source = "closeRequest.lastMsgReceived.first.value")
@Mapping(target = "clientIdentifierValue", source = "authorIdentifier.identifier.value")
XtaCloseRequest mapXtaCloseRequest(MsgBoxCloseRequestType closeRequest, PartyType authorIdentifier);
@Mapping(target = "messageId", source = "fetchRequest.msgSelector.messageID.first.value")
@Mapping(target = "clientIdentifierValue", source = "authorIdentifier.identifier.value")
XtaGetMessageRequest mapXtaGetMessageRequest(MsgBoxFetchRequest fetchRequest, PartyType authorIdentifier);
}
src/main/java/de/ozgcloud/xta/test/app/mapper/ResponseMapper.java
+ 29
− 23
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import java.io.File;
import java.math.BigInteger;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import jakarta.activation.DataHandler;
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;
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.XtaMessageMetaDataListing;
import de.ozgcloud.xta.test.app.util.XtaIdGenerator;
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.DeliveryAttributesType;
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;
import genv3.eu.osci.ws.x2014.x10.transport.QualifierType;
import jakarta.activation.DataHandler;
import jakarta.activation.FileDataSource;
import lombok.SneakyThrows;
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;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import java.io.File;
import java.math.BigInteger;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
@Mapper(
unmappedTargetPolicy = ReportingPolicy.ERROR,
imports = { BigInteger.class }
......@@ -57,13 +58,13 @@ public interface ResponseMapper {
@Mapping(target = "qualifier.messageType", source = ".")
@Mapping(target = "msgIdentification.messageID.value", source = "messageId")
@Mapping(target = "originators.author.identifier", source = "authorIdentifier")
@Mapping(target = "originators.sender.identifier", expression = "java( mapPartyIdentifierTypeFromIdentifier(SENDER_IDENTIFIER) )")
@Mapping(target = "originators.sender.identifier", expression = "java( mapPartyIdentifierType(SENDER_IDENTIFIER) )")
@Mapping(target = "destinations.reader.identifier", source = "readerIdentifier")
@Mapping(target = "msgSize", source = "messageSize")
@Mapping(target = "testMsg", ignore = true)
@Mapping(target = "deliveryAttributes", expression = "java( defaultDeliveryAttributes() )")
@Mapping(target = "messageProperties", ignore = true)
MessageMetaData mapMessageMetaDataFromXtaMessageMetaData(XtaMessageMetaData xtaMessageMetaData);
MessageMetaData mapMessageMetaData(XtaMessageMetaData xtaMessageMetaData);
@Named("mapBusinessScenario")
default QualifierType.BusinessScenario mapBusinessScenario(XtaMessageMetaData xtaMessageMetaData) {
......@@ -129,6 +130,10 @@ public interface ResponseMapper {
return DatatypeFactory.newInstance().newXMLGregorianCalendar(isoTimeString);
}
default MsgBoxResponseType createGetMessageResponseHeader(XtaIdGenerator xtaIdGenerator) {
return mapMsgBoxResponseTypeFromRequestID(xtaIdGenerator.generateRequestId().toString());
}
@Mapping(target = "itemsPending", expression = "java( BigInteger.ZERO )")
@Mapping(target = "msgBoxRequestID", source = "requestId")
@Mapping(target = "noMessageAvailable", expression = "java( null )")
......@@ -164,4 +169,5 @@ public interface ResponseMapper {
@Mapping(target = "itemsPending", ignore = true)
@Mapping(target = "noMessageAvailable.reason", source = "errorString")
MsgBoxResponseType mapMsgBoxResponseTypeError(String errorString);
}
src/main/java/de/ozgcloud/xta/test/app/model/XtaCloseRequest.java 0 → 100644
+ 12
− 0
View file @ d7e81766
package de.ozgcloud.xta.test.app.model;
import jakarta.validation.constraints.NotBlank;
import lombok.Builder;
@Builder
public record XtaCloseRequest(
@NotBlank String messageId,
@NotBlank String clientIdentifierValue
) {
}
src/main/java/de/ozgcloud/xta/test/app/model/XtaGetMessageRequest.java 0 → 100644
+ 12
− 0
View file @ d7e81766
package de.ozgcloud.xta.test.app.model;
import jakarta.validation.constraints.NotBlank;
import lombok.Builder;
@Builder
public record XtaGetMessageRequest(
@NotBlank String messageId,
@NotBlank String clientIdentifierValue
) {
}
src/main/java/de/ozgcloud/xta/test/app/server/MsgBoxPortImpl.java
+ 27
− 100
View file @ d7e81766
package de.ozgcloud.xta.test.app.server;
import static de.ozgcloud.xta.test.app.model.XtaConstants.*;
import java.util.Optional;
import genv3.de.xoev.transport.xta.x211.*;
import jakarta.jws.WebService;
import org.apache.cxf.annotations.SchemaValidation;
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.service.ParameterValidatorService;
import de.ozgcloud.xta.test.app.mapper.ExceptionMapper;
import de.ozgcloud.xta.test.app.mapper.RequestMapper;
import de.ozgcloud.xta.test.app.mapper.ResponseMapper;
import de.ozgcloud.xta.test.app.service.RequestValidator;
import de.ozgcloud.xta.test.app.service.XtaMessageService;
import de.ozgcloud.xta.test.app.service.XtaParameter;
import de.ozgcloud.xta.test.app.util.XtaIdGenerator;
import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxFetchRequest;
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.de.xoev.transport.xta.x211.InvalidMessageIDException;
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 lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
......@@ -33,10 +25,11 @@ import lombok.extern.log4j.Log4j2;
@Log4j2
public class MsgBoxPortImpl implements MsgBoxPortType {
private final ParameterValidatorService validator;
private final RequestValidator requestValidator;
private final RequestMapper requestMapper;
private final ExceptionMapper exceptionMapper;
private final ResponseMapper responseMapper;
private final XtaIdGenerator xtaIdGenerator;
private final XtaMessageService messageService;
/*
......@@ -55,43 +48,17 @@ public class MsgBoxPortImpl implements MsgBoxPortType {
throws XTAWSTechnicalProblemException, InvalidMessageIDException, PermissionDeniedException {
log.info("Executing operation getMessage");
validateFetchRequest(fetchRequest);
var request = requestMapper.mapXtaGetMessageRequest(fetchRequest, authorIdentifier);
requestValidator.validate(request);
String messageId = requestMapper.mapMessageIdFromMsgBoxFetchRequest(fetchRequest);
XtaMessage message = getXtaMessageOrThrow(messageId);
String msgBoxRequestId = xtaIdGenerator.generateRequestId().toString();
var message = messageService.getMessage(request)
.orElseThrow(() -> createInvalidMessageIdException(request.messageId(), request.clientIdentifierValue()));
messageMetaData.value = responseMapper.mapMessageMetaDataFromXtaMessageMetaData(message.metaData());
fetchResponseHeader.value = responseMapper.mapMsgBoxResponseTypeFromRequestID(msgBoxRequestId);
messageMetaData.value = responseMapper.mapMessageMetaData(message.metaData());
fetchResponseHeader.value = responseMapper.createGetMessageResponseHeader(xtaIdGenerator);
return responseMapper.mapGenericContentContainerFromXtaMessage(message);
}
private void validateFetchRequest(MsgBoxFetchRequest fetchRequest) throws XTAWSTechnicalProblemException {
if (!(checkMessageSelectionSupported(fetchRequest.getMsgSelector())
&& validator.isListSizeEquals(fetchRequest.getMsgSelector().getMessageID(), 1, "MessageID"))) {
throw buildTechnicalProblemException("Invalid fetch request");
}
}
private boolean checkMessageSelectionSupported(MsgSelector msgSelector) {
// Selection only by messageID is required
return msgSelector != null
&& msgSelector.isNewEntry() == null
&& msgSelector.getMsgBoxEntryTimeFrom() == null
&& msgSelector.getMsgBoxEntryTimeTo() == null
&& ! msgSelector.getMessageID().isEmpty()
&& msgSelector.getRelatesTo().isEmpty()
&& msgSelector.getExtension() == null;
}
private XtaMessage getXtaMessageOrThrow(String messageId) throws InvalidMessageIDException {
Optional<XtaMessage> message = messageService.getMessage(messageId);
if (message.isEmpty()) {
throw buildInvalidMessageIDException("No message with messageID \"" + messageId + "\" available.");
}
return message.get();
}
/*
* (non-Javadoc)
* @see genv3.de.xoev.transport.xta.x211.MsgBoxPortType#getStatusList(genv3.eu.osci.ws.x2008.x05.transport.
......@@ -105,42 +72,16 @@ public class MsgBoxPortImpl implements MsgBoxPortType {
final jakarta.xml.ws.Holder<genv3.eu.osci.ws.x2008.x05.transport.MsgBoxResponseType> msgBoxResponseHeader)
throws XTAWSTechnicalProblemException, PermissionDeniedException {
log.info("Executing operation getStatusList");
validateGetStatusListRequest(statusListRequest);
if (validator.isNotNull(statusListRequest.getMsgSelector(), "msgSelector")) {
msgBoxResponseHeader.value = responseMapper.mapMsgBoxResponseTypeError(
"SearchArgsInvalid: This test server doesn't support message selection in the 'getStatusList' operation.");
return new MsgStatusListType();
}
var request = requestMapper.mapMessageMetaDataListingRequest(statusListRequest, authorIdentifier);
requestValidator.validate(request);
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")
&& statusListRequest.getListForm().equalsIgnoreCase("MessageMetaData")
&& validator.isNotNull(statusListRequest.getMaxListItems(), "maxListItems"))) {
throw buildTechnicalProblemException("Invalid getStatusList request");
}
}
private int getMaxListItemsOrThrow(MsgBoxStatusListRequestType statusListRequest) throws XTAWSTechnicalProblemException {
try {
int maxListItems = statusListRequest.getMaxListItems().intValueExact();
if (maxListItems <= 0) {
throw buildTechnicalProblemException("Invalid maxListItems value");
}
return maxListItems;
} catch (ArithmeticException e) {
throw buildTechnicalProblemException("Invalid maxListItems value");
}
}
/*
* (non-Javadoc)
* @see genv3.de.xoev.transport.xta.x211.MsgBoxPortType#getNextMessage(genv3.eu.osci.ws.x2008.x05.transport.
......@@ -186,32 +127,18 @@ public class MsgBoxPortImpl implements MsgBoxPortType {
final genv3.eu.osci.ws.x2014.x10.transport.PartyType authorIdentifier)
throws XTAWSTechnicalProblemException, InvalidMessageIDException, PermissionDeniedException {
log.info("Executing operation close");
boolean messageIdsValid = true;
for (AttributedURIType messageId : closeRequest.getLastMsgReceived()) {
validator.isNotBlank(messageId.getValue(), XtaParameter.MESSAGE_ID);
messageIdsValid &= messageService.closeMessage(messageId.getValue());
}
if( ! messageIdsValid ) {
throw buildInvalidMessageIDException("One or more message IDs are invalid.");
}
}
var request = requestMapper.mapXtaCloseRequest(closeRequest, authorIdentifier);
requestValidator.validate(request);
private XTAWSTechnicalProblemException buildTechnicalProblemException(String message) {
var faultInfo = new XTAWSTechnicalProblemExceptionType();
faultInfo.getErrorCode().setCode(ERROR_CODE_INTERNAL_TECHNICAL_PROBLEM);
faultInfo.getErrorCode().setName(ERROR_CODE_INTERNAL_TECHNICAL_PROBLEM_DESCRIPTION);
faultInfo.getErrorCode().setListURI(ERROR_CODE_LIST_URN);
faultInfo.getErrorCode().setListVersionID(ERROR_CODE_LIST_VERSION);
return new XTAWSTechnicalProblemException(message, faultInfo);
if (!messageService.closeMessage(request)) {
throw createInvalidMessageIdException(request.messageId(), request.clientIdentifierValue());
}
}
private InvalidMessageIDException buildInvalidMessageIDException(String message) {
var faultInfo = new InvalidMessageIDExceptionType();
faultInfo.getErrorCode().setCode(ERROR_CODE_MESSAGE_ID_UNKNOWN);
faultInfo.getErrorCode().setName(ERROR_CODE_MESSAGE_ID_UNKNOWN_DESCRIPTION);
faultInfo.getErrorCode().setListURI(ERROR_CODE_LIST_URN);
faultInfo.getErrorCode().setListVersionID(ERROR_CODE_LIST_VERSION);
return new InvalidMessageIDException(message, faultInfo);
private InvalidMessageIDException createInvalidMessageIdException(String messageId, String clientIdentifierValue) {
return exceptionMapper.createInvalidMessageIDException(
"No message with messageID \"%s\" available for identifier \"%s\"."
.formatted(messageId, clientIdentifierValue));
}
}
src/main/java/de/ozgcloud/xta/test/app/service/RequestValidator.java 0 → 100644
+ 49
− 0
View file @ d7e81766
package de.ozgcloud.xta.test.app.service;
import java.util.Collection;
import java.util.function.Function;
import java.util.stream.Collectors;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import org.springframework.stereotype.Service;
import de.ozgcloud.xta.test.app.mapper.ExceptionMapper;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
import lombok.RequiredArgsConstructor;
@Service
@RequiredArgsConstructor
public class RequestValidator {
private static final Validator VALIDATOR;
static {
try (var factory = Validation.buildDefaultValidatorFactory()) {
VALIDATOR = factory.getValidator();
}
}
private final ExceptionMapper exceptionMapper;
public <T> void validate(T request) throws XTAWSTechnicalProblemException {
validate(request, violations ->
exceptionMapper.createTechnicalProblemException("Request is invalid:\n" + getViolationsDescription(violations))
);
}
private <T> String getViolationsDescription(Collection<ConstraintViolation<T>> violations) {
return violations.stream()
.map(v -> "'%s' %s".formatted(v.getPropertyPath().toString(), v.getMessage()))
.collect(Collectors.joining("\n"));
}
private <T, E extends Exception> void validate(T request, Function<Collection<ConstraintViolation<T>>, E> violationsConsumer) throws E {
var violations = VALIDATOR.validate(request);
if (!violations.isEmpty()) {
throw violationsConsumer.apply(violations);
}
}
}
src/main/java/de/ozgcloud/xta/test/app/service/XtaCloseRequestTestFactory.java 0 → 100644
+ 19
− 0
View file @ d7e81766
package de.ozgcloud.xta.test.app.service;
import de.ozgcloud.xta.test.app.model.XtaCloseRequest;
public class XtaCloseRequestTestFactory {
public static final String CLOSE_REQUEST_MESSAGE_ID = "close-request-message-id";
public static final String READER_IDENTIFIER_VALUE = "reader-identifier";
public static XtaCloseRequest create() {
return createBuilder().build();
}
public static XtaCloseRequest.XtaCloseRequestBuilder createBuilder() {
return XtaCloseRequest.builder()
.messageId(CLOSE_REQUEST_MESSAGE_ID)
.clientIdentifierValue(READER_IDENTIFIER_VALUE);
}
}
src/main/java/de/ozgcloud/xta/test/app/service/XtaMessageService.java
+ 16
− 4
View file @ d7e81766
......@@ -2,10 +2,13 @@ package de.ozgcloud.xta.test.app.service;
import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
import org.springframework.stereotype.Service;
import de.ozgcloud.xta.test.app.data.XtaMessageRepository;
import de.ozgcloud.xta.test.app.model.XtaCloseRequest;
import de.ozgcloud.xta.test.app.model.XtaGetMessageRequest;
import de.ozgcloud.xta.test.app.model.XtaMessage;
import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListing;
......@@ -36,11 +39,20 @@ public class XtaMessageService {
.toList();
}
public Optional<XtaMessage> getMessage(String identifierValue) {
return messageRepository.get(identifierValue);
public Optional<XtaMessage> getMessage(XtaGetMessageRequest request) {
return messageRepository.get(request.messageId())
.filter(isAuthorOrReaderOfMessage(request.clientIdentifierValue()));
}
public boolean closeMessage(String identifierValue) {
return messageRepository.delete(identifierValue);
Predicate<XtaMessage> isAuthorOrReaderOfMessage(String clientIdentifierValue) {
return m -> m.metaData().readerIdentifier().value().equals(clientIdentifierValue)
|| m.metaData().authorIdentifier().value().equals(clientIdentifierValue);
}
public boolean closeMessage(XtaCloseRequest request) {
return messageRepository.deleteByMessageIdAndReaderIdentifierValue(
request.messageId(),
request.clientIdentifierValue()
);
}
}
src/test/java/de/ozgcloud/xta/test/app/data/XtaMessageRepositoryTest.java
+ 2
− 2
View file @ d7e81766
package de.ozgcloud.xta.test.app.data;
import static de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory.*;
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.*;
......@@ -17,12 +17,12 @@ import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.InjectMocks;
import org.mockito.Spy;
import de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory;
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 {
......
src/test/java/de/ozgcloud/xta/test/app/mapper/ExceptionMapperTest.java 0 → 100644
+ 126
− 0
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import static de.ozgcloud.xta.test.app.model.XtaConstants.*;
import static org.assertj.core.api.Assertions.*;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mapstruct.factory.Mappers;
import genv3.de.xoev.transport.xta.x211.CodeFehlernummer;
import genv3.de.xoev.transport.xta.x211.InvalidMessageIDException;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
class ExceptionMapperTest {
private final ExceptionMapper mapper = Mappers.getMapper(ExceptionMapper.class);
@DisplayName("create invalid message id exception")
@Nested
class TestCreateInvalidMessageIdException {
private final String exceptionMessage = "test message";
@DisplayName("should map message")
@Test
void shouldMapMessage() {
var result = createException();
assertThat(result.getMessage()).isEqualTo(exceptionMessage);
}
@DisplayName("should map error code")
@Test
void shouldMapErrorCode() {
var result = createExceptionErrorCode();
assertThat(result.getCode()).isEqualTo(ERROR_CODE_MESSAGE_ID_UNKNOWN);
}
@DisplayName("should map error name")
@Test
void shouldMapErrorName() {
var result = createExceptionErrorCode();
assertThat(result.getName()).isEqualTo(ERROR_CODE_MESSAGE_ID_UNKNOWN_DESCRIPTION);
}
@DisplayName("should map list uri")
@Test
void shouldMapListUri() {
var result = createExceptionErrorCode();
assertThat(result.getListURI()).isEqualTo(ERROR_CODE_LIST_URN);
}
@DisplayName("should map list version id")
@Test
void shouldMapListVersionId() {
var result = createExceptionErrorCode();
assertThat(result.getListVersionID()).isEqualTo(ERROR_CODE_LIST_VERSION);
}
private InvalidMessageIDException createException() {
return mapper.createInvalidMessageIDException(exceptionMessage);
}
private CodeFehlernummer createExceptionErrorCode() {
return createException().getFaultInfo().getErrorCode();
}
}
@DisplayName("create technical problem exception")
@Nested
class TestCreateTechnicalProblemException {
private final String exceptionMessage = "test message";
@DisplayName("should map message")
@Test
void shouldMapMessage() {
var result = createException();
assertThat(result.getMessage()).isEqualTo(exceptionMessage);
}
@DisplayName("should map error code")
@Test
void shouldMapErrorCode() {
var result = createExceptionErrorCode();
assertThat(result.getCode()).isEqualTo(ERROR_CODE_INTERNAL_TECHNICAL_PROBLEM);
}
@DisplayName("should map error name")
@Test
void shouldMapErrorName() {
var result = createExceptionErrorCode();
assertThat(result.getName()).isEqualTo(ERROR_CODE_INTERNAL_TECHNICAL_PROBLEM_DESCRIPTION);
}
@DisplayName("should map list uri")
@Test
void shouldMapListUri() {
var result = createExceptionErrorCode();
assertThat(result.getListURI()).isEqualTo(ERROR_CODE_LIST_URN);
}
@DisplayName("should map list version id")
@Test
void shouldMapListVersionId() {
var result = createExceptionErrorCode();
assertThat(result.getListVersionID()).isEqualTo(ERROR_CODE_LIST_VERSION);
}
private XTAWSTechnicalProblemException createException() {
return mapper.createTechnicalProblemException(exceptionMessage);
}
private CodeFehlernummer createExceptionErrorCode() {
return createException().getFaultInfo().getErrorCode();
}
}
}
\ No newline at end of file
src/test/java/de/ozgcloud/xta/test/app/mapper/PartyTypeTestFactory.java
+ 1
− 2
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import static de.ozgcloud.xta.test.app.service.MessageMetaDataTestFactory.*;
import static de.ozgcloud.xta.test.app.factory.MessageMetaDataTestFactory.*;
import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
import genv3.eu.osci.ws.x2014.x10.transport.PartyType;
......
src/test/java/de/ozgcloud/xta/test/app/mapper/RequestMapperTest.java
+ 7
− 51
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import static de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory.*;
import static de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory.*;
import static org.assertj.core.api.Assertions.*;
import java.nio.file.Files;
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.MsgSelector;
import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
import lombok.SneakyThrows;
import org.apache.cxf.ws.addressing.AttributedURIType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
......@@ -20,19 +12,18 @@ import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mapstruct.factory.Mappers;
import de.ozgcloud.xta.test.app.factory.AttributedURITypeTestFactory;
import de.ozgcloud.xta.test.app.factory.ContentTypeTestFactory;
import de.ozgcloud.xta.test.app.factory.GenericContentContainerTestFactory;
import de.ozgcloud.xta.test.app.factory.MessageMetaDataTestFactory;
import de.ozgcloud.xta.test.app.factory.MsgBoxStatusListRequestTypeTestFactory;
import de.ozgcloud.xta.test.app.factory.QualifierTypeBusinessScenarioTestFactory;
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.GenericContentContainerTestFactory;
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;
import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxStatusListRequestType;
import genv3.eu.osci.ws.x2008.x05.transport.MsgSelector;
import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
import genv3.eu.osci.ws.x2014.x10.transport.PartyIdentifierType;
......@@ -166,41 +157,6 @@ public class RequestMapperTest {
}
}
@Nested
class MapMaxListItems {
private MsgBoxStatusListRequestType fetchRequest;
@DisplayName("Should map max list items from MsgBoxStatusListRequestType")
@Test
void shouldMapMaxListItems() {
fetchRequest = MsgBoxStatusListRequestTypeTestFactory.create(10);
var maxListItems = requestMapper.mapMaxListItems(fetchRequest);
assertThat(maxListItems).isEqualTo(10);
}
@DisplayName("Should map unsupported negative max list items value to maximum integer value")
@Test
void shouldMapMaxListItemsToMaxValue() {
fetchRequest = MsgBoxStatusListRequestTypeTestFactory.create(-1);
var maxListItems = requestMapper.mapMaxListItems(fetchRequest);
assertThat(maxListItems).isEqualTo(Integer.MAX_VALUE);
}
@DisplayName("Should map unsupported large max list items value to maximum integer value")
@Test
void shouldMapMaxListItemsToMaxValueWhenOverflowing() {
fetchRequest = MsgBoxStatusListRequestTypeTestFactory.create(Long.MAX_VALUE);
var maxListItems = requestMapper.mapMaxListItems(fetchRequest);
assertThat(maxListItems).isEqualTo(Integer.MAX_VALUE);
}
}
@DisplayName("map message meta data listing request")
@Nested
class TestMapMessageMetaDataListingRequest {
......
src/test/java/de/ozgcloud/xta/test/app/mapper/ResponseMapperTest.java
+ 45
− 6
View file @ d7e81766
package de.ozgcloud.xta.test.app.mapper;
import static de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory.*;
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 static org.mockito.Mockito.*;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
......@@ -13,15 +14,13 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mapstruct.factory.Mappers;
import org.mockito.Mock;
import de.ozgcloud.xta.test.app.factory.XtaFileTestFactory;
import de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory;
import de.ozgcloud.xta.test.app.factory.XtaMessageTestFactory;
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 de.ozgcloud.xta.test.app.service.XtaMessageMetaDataTestFactory;
import de.ozgcloud.xta.test.app.util.XtaId;
import de.ozgcloud.xta.test.app.util.XtaIdGenerator;
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;
......@@ -380,4 +379,44 @@ public class ResponseMapperTest {
}
}
}
@DisplayName("create get message response header")
@Nested
class TestCreateGetMessageResponseHeader {
@Mock
private XtaIdGenerator xtaIdGenerator;
@Mock
private XtaId xtaId;
@BeforeEach
void mock() {
when(xtaIdGenerator.generateRequestId()).thenReturn(xtaId);
when(xtaId.toString()).thenReturn(REQUEST_ID);
}
@DisplayName("should map message box response type from request id")
@Test
void shouldMapMsgBoxResponseTypeFromRequestId() {
var result = mapper.createGetMessageResponseHeader(xtaIdGenerator);
assertThat(result.getMsgBoxRequestID()).isEqualTo(REQUEST_ID);
}
@DisplayName("should map items pending to zero")
@Test
void shouldMapItemsPendingToZero() {
var result = mapper.createGetMessageResponseHeader(xtaIdGenerator);
assertThat(result.getItemsPending()).isEqualTo(BigInteger.ZERO);
}
@DisplayName("should set no messages available to null")
@Test
void shouldSetNoMessagesAvailableToNull() {
var result = mapper.createGetMessageResponseHeader(xtaIdGenerator);
assertThat(result.getNoMessageAvailable()).isNull();
}
}
}
src/test/java/de/ozgcloud/xta/test/app/mapper/XtaFileTestFactory.java
+ 27
− 0
View file @ d7e81766
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";
public static XtaFile create() {
return createBuilder().build();
}
static XtaFile.XtaFileBuilder createBuilder() {
File tfile = TempFileTestFactory.createFile(XTA_CONTENT);
return XtaFile.builder()
.name(NAME)
.contentType(ZIP_CONTENT_TYPE)
.file(tfile)
.size(BigInteger.valueOf(tfile.getTotalSpace()));
}
}
src/test/java/de/ozgcloud/xta/test/app/mapper/XtaMessageTestFactory.java
+ 1
− 1
View file @ d7e81766
......@@ -2,8 +2,8 @@ package de.ozgcloud.xta.test.app.mapper;
import java.util.List;
import de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory;
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";
......
src/test/java/de/ozgcloud/xta/test/app/server/MsgBoxPortImplTest.java
+ 232
− 217
View file @ d7e81766
package de.ozgcloud.xta.test.app.server;
import static de.ozgcloud.xta.test.app.factory.MessageMetaDataTestFactory.*;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.math.BigInteger;
import java.util.List;
import java.util.Optional;
import genv3.de.xoev.transport.xta.x211.GenericContentContainer;
import genv3.de.xoev.transport.xta.x211.InvalidMessageIDException;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxCloseRequestType;
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.MsgStatusListType;
import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
import genv3.eu.osci.ws.x2014.x10.transport.PartyType;
import jakarta.xml.ws.Holder;
import lombok.SneakyThrows;
import org.assertj.core.api.Condition;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import de.ozgcloud.xta.test.app.factory.AttributedURITypeTestFactory;
import de.ozgcloud.xta.test.app.factory.MsgBoxCloseRequestTypeTestFactory;
import de.ozgcloud.xta.test.app.factory.MsgBoxFetchRequestTestFactory;
import de.ozgcloud.xta.test.app.factory.MsgBoxStatusListRequestTypeTestFactory;
import de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory;
import de.ozgcloud.xta.test.app.factory.XtaMessageTestFactory;
import de.ozgcloud.xta.test.app.mapper.ExceptionMapper;
import de.ozgcloud.xta.test.app.mapper.RequestMapper;
import de.ozgcloud.xta.test.app.mapper.ResponseMapper;
import de.ozgcloud.xta.test.app.model.XtaCloseRequest;
import de.ozgcloud.xta.test.app.model.XtaGetMessageRequest;
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.service.ParameterValidatorService;
import de.ozgcloud.xta.test.app.model.XtaMessageMetaDataListingRequest;
import de.ozgcloud.xta.test.app.service.RequestValidator;
import de.ozgcloud.xta.test.app.service.XtaMessageService;
import de.ozgcloud.xta.test.app.util.XtaId;
import de.ozgcloud.xta.test.app.util.XtaIdGenerator;
import genv3.de.xoev.transport.xta.x211.GenericContentContainer;
import genv3.de.xoev.transport.xta.x211.InvalidMessageIDException;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
import genv3.eu.osci.ws.x2008.x05.transport.MsgBoxCloseRequestType;
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.MsgStatusListType;
import genv3.eu.osci.ws.x2014.x10.transport.MessageMetaData;
import genv3.eu.osci.ws.x2014.x10.transport.PartyType;
import lombok.SneakyThrows;
public class MsgBoxPortImplTest {
@Spy
private ParameterValidatorService validator;
@Spy
@InjectMocks
private MsgBoxPortImpl msgBoxPortImpl;
@Mock
private RequestMapper requestMapper;
@Mock
private RequestValidator requestValidator;
@Mock
private ExceptionMapper exceptionMapper;
@Mock
private ResponseMapper responseMapper;
@Mock
private XtaIdGenerator xtaIdGenerator;
@Mock
private XtaMessageService xtaMessageService;
@InjectMocks
private MsgBoxPortImpl msgBoxPortImpl;
@DisplayName("get message")
@Nested
class GetMessage {
public static final XtaId REQUEST_ID = new XtaId("urn", XtaIdGenerator.REQUEST_ID_NAMESPACE, XtaIdGenerator.APPLICATION_NAME, "test-id");
class TestGetMessage {
private static final String MESSAGE_ID = "message-id";
private static final String CLIENT_IDENTIFIER_VALUE = "client-identifier";
@Mock
private MsgBoxFetchRequest fetchRequest;
@Mock
private PartyType authorIdentifier;
private Holder<MessageMetaData> messageMetaDataHolder;
private Holder<MsgBoxResponseType> responseHeaderHolder;
@Mock
private XtaMessage xtaMessage;
@Mock
GenericContentContainer mappedGenericContentContainer;
private GenericContentContainer mappedGenericContentContainer;
@Mock
MessageMetaData mappedMessageMetaData;
private MessageMetaData mappedMessageMetaData;
@Mock
MsgBoxResponseType mappedFetchResponseHeader;
private MsgBoxResponseType mappedFetchResponseHeader;
@BeforeEach
void beforeEach() {
fetchRequest = MsgBoxFetchRequestTestFactory.create();
MessageMetaData messageMetaData = new MessageMetaData();
MsgBoxResponseType fetchResponseHeader = new MsgBoxResponseType();
messageMetaDataHolder = new Holder<>(messageMetaData);
responseHeaderHolder = new Holder<>(fetchResponseHeader);
xtaMessage = XtaMessageTestFactory.create(MsgBoxFetchRequestTestFactory.MESSAGE_ID.getValue());
}
void setupMocksForValidRequest() {
when(xtaIdGenerator.generateRequestId()).thenReturn(REQUEST_ID);
when(xtaMessageService.getMessage(MsgBoxFetchRequestTestFactory.MESSAGE_ID.getValue())).thenReturn(Optional.of(xtaMessage));
when(responseMapper.mapGenericContentContainerFromXtaMessage(xtaMessage)).thenReturn(mappedGenericContentContainer);
when(responseMapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessage.metaData())).thenReturn(mappedMessageMetaData);
when(responseMapper.mapMsgBoxResponseTypeFromRequestID(REQUEST_ID.toString())).thenReturn(mappedFetchResponseHeader);
}
private Holder<MessageMetaData> messageMetaDataHolder;
private Holder<MsgBoxResponseType> responseHeaderHolder;
private XtaGetMessageRequest request;
@Test
void shouldAcceptValidRequest() {
setupMocksForValidRequest();
@BeforeEach
void mock() {
request = XtaGetMessageRequest.builder()
.messageId(MESSAGE_ID)
.clientIdentifierValue(CLIENT_IDENTIFIER_VALUE)
.build();
assertThatNoException().isThrownBy(
() -> msgBoxPortImpl.getMessage(fetchRequest, authorIdentifier, messageMetaDataHolder, responseHeaderHolder));
messageMetaDataHolder = new Holder<>();
responseHeaderHolder = new Holder<>();
when(requestMapper.mapXtaGetMessageRequest(fetchRequest, authorIdentifier)).thenReturn(request);
}
@Test
void shouldRejectRequestWithoutMessageId() {
fetchRequest.getMsgSelector().getMessageID().clear();
@DisplayName("with valid request")
@Nested
class TestWithValidRequest {
@BeforeEach
void setup() {
when(xtaMessageService.getMessage(request)).thenReturn(Optional.of(xtaMessage));
assertThatExceptionOfType(XTAWSTechnicalProblemException.class).isThrownBy(
() -> msgBoxPortImpl.getMessage(fetchRequest, authorIdentifier, messageMetaDataHolder, responseHeaderHolder))
.has(technicalProblemErrorCodeCondition());
when(responseMapper.mapMessageMetaData(xtaMessage.metaData())).thenReturn(mappedMessageMetaData);
when(responseMapper.createGetMessageResponseHeader(xtaIdGenerator)).thenReturn(mappedFetchResponseHeader);
when(responseMapper.mapGenericContentContainerFromXtaMessage(xtaMessage)).thenReturn(mappedGenericContentContainer);
}
@DisplayName("should assign message meta data")
@Test
void shouldRejectRequestWithMultipleMessageIds() {
fetchRequest.getMsgSelector().getMessageID().add(AttributedURITypeTestFactory.create("urn:de:xta:messageId:extra-id"));
void shouldAssignMessageMetaData() {
getMessage();
assertThatExceptionOfType(XTAWSTechnicalProblemException.class).isThrownBy(
() -> msgBoxPortImpl.getMessage(fetchRequest, authorIdentifier, messageMetaDataHolder, responseHeaderHolder))
.has(technicalProblemErrorCodeCondition());
assertThat(messageMetaDataHolder.value).isEqualTo(mappedMessageMetaData);
}
@DisplayName("should assign fetch response header")
@Test
void shouldRejectRequestWithUnknownMessageId() {
when(xtaMessageService.getMessage(MsgBoxFetchRequestTestFactory.MESSAGE_ID.getValue())).thenReturn(Optional.empty());
void shouldAssignFetchResponseHeader() {
getMessage();
assertThatExceptionOfType(InvalidMessageIDException.class).isThrownBy(
() -> msgBoxPortImpl.getMessage(fetchRequest, authorIdentifier, messageMetaDataHolder, responseHeaderHolder))
.has(invalidMessageIDExceptionCondition());
assertThat(responseHeaderHolder.value).isEqualTo(mappedFetchResponseHeader);
}
@DisplayName("should return")
@Test
void shouldRejectRequestWithInvalidMessageSelector() {
fetchRequest.getMsgSelector().setNewEntry(false);
void shouldReturn() {
var genericContentContainer = getMessage();
assertThatExceptionOfType(XTAWSTechnicalProblemException.class).isThrownBy(
() -> msgBoxPortImpl.getMessage(fetchRequest, authorIdentifier, messageMetaDataHolder, responseHeaderHolder))
.has(technicalProblemErrorCodeCondition());
assertThat(genericContentContainer).isEqualTo(mappedGenericContentContainer);
}
}
@Test
void shouldReturnMessage() {
setupMocksForValidRequest();
var messageContentContainer = executeGetMessageWithPossibleException();
@DisplayName("with invalid message id")
@Nested
class TestWithInvalidMessageId {
assertThat(messageContentContainer).isSameAs(mappedGenericContentContainer);
}
@Mock
private InvalidMessageIDException exception;
@DisplayName("should throw exception")
@Test
void shouldSetMessageMetaData() {
setupMocksForValidRequest();
void shouldThrowException() {
when(xtaMessageService.getMessage(request)).thenReturn(Optional.empty());
when(exceptionMapper.createInvalidMessageIDException(any())).thenReturn(exception);
executeGetMessageWithPossibleException();
assertThat(messageMetaDataHolder.value).isSameAs(mappedMessageMetaData);
assertThatThrownBy(TestGetMessage.this::getMessage)
.isEqualTo(exception);
}
}
@Test
void shouldSetResponseHeader() {
setupMocksForValidRequest();
@DisplayName("with invalid request")
@Nested
class TestWithInvalidRequest {
executeGetMessageWithPossibleException();
@BeforeEach
@SneakyThrows
void setup() {
doThrow(new XTAWSTechnicalProblemException()).when(requestValidator).validate(request);
}
assertThat(responseHeaderHolder.value).isSameAs(mappedFetchResponseHeader);
@DisplayName("should throw exception")
@Test
void shouldThrowException() {
assertThatThrownBy(TestGetMessage.this::getMessage)
.isInstanceOf(XTAWSTechnicalProblemException.class);
}
}
@SneakyThrows
private GenericContentContainer executeGetMessageWithPossibleException() {
private GenericContentContainer getMessage() {
return msgBoxPortImpl.getMessage(fetchRequest, authorIdentifier, messageMetaDataHolder, responseHeaderHolder);
}
}
@DisplayName("get status list")
@Nested
class GetStatusList {
public static final String MESSAGE_ID = "urn:de:xta:messageid:test-id";
public static final XtaId REQUEST_ID = new XtaId("urn", XtaIdGenerator.REQUEST_ID_NAMESPACE, XtaIdGenerator.APPLICATION_NAME, "test-id");
class TestGetStatusList {
@Mock
private MsgBoxStatusListRequestType statusListRequest;
@Mock
private PartyType authorIdentifier;
private Holder<MsgBoxResponseType> responseHeaderHolder;
@Mock
private MessageMetaData mappedMessageMetaData;
private Holder<MsgBoxResponseType> msgBoxResponseHeader;
@Mock
private MsgBoxResponseType mappedMsgBoxResponseHeader;
private XtaMessageMetaDataListingRequest request;
@BeforeEach
void beforeEach() {
statusListRequest = MsgBoxStatusListRequestTypeTestFactory.create(50);
MsgBoxResponseType msgBoxResponseHeader = new MsgBoxResponseType();
responseHeaderHolder = new Holder<>(msgBoxResponseHeader);
}
void mock() {
when(requestMapper.mapMessageMetaDataListingRequest(statusListRequest, authorIdentifier)).thenReturn(request);
void setupMocksForValidRequest() {
when(xtaIdGenerator.generateRequestId()).thenReturn(REQUEST_ID);
XtaMessageMetaData xtaMessageMetaData = XtaMessageMetaDataTestFactory.create(MESSAGE_ID);
XtaMessageMetaDataListing xtaMessageMetaDataListing = new XtaMessageMetaDataListing(REQUEST_ID.toString(), BigInteger.ONE,
List.of(xtaMessageMetaData));
when(xtaMessageService.getStatusList(REQUEST_ID.toString(), 50)).thenReturn(xtaMessageMetaDataListing);
when(responseMapper.mapMessageMetaDataFromXtaMessageMetaData(xtaMessageMetaData)).thenReturn(mappedMessageMetaData);
when(responseMapper.mapMsgBoxResponseTypeFromXtaMessageMetaDataListing(xtaMessageMetaDataListing)).thenReturn(mappedMsgBoxResponseHeader);
msgBoxResponseHeader = new Holder<>();
}
@Test
void shouldAcceptValidRequest() {
setupMocksForValidRequest();
@DisplayName("with valid request")
@Nested
class TestWithValidRequest {
@Mock
private XtaMessageMetaDataListing listing;
@Mock
private MsgStatusListType statusListType;
@Mock
private MsgBoxResponseType mappedMsgBoxResponseHeader;
assertThatNoException().isThrownBy(
() -> msgBoxPortImpl.getStatusList(statusListRequest, authorIdentifier, responseHeaderHolder));
@BeforeEach
void setup() {
when(xtaMessageService.getStatusList(request)).thenReturn(listing);
when(responseMapper.mapMsgStatusListType(listing)).thenReturn(statusListType);
when(responseMapper.mapMsgBoxResponseType(listing)).thenReturn(mappedMsgBoxResponseHeader);
}
@DisplayName("should return")
@Test
void shouldRejectRequestWithoutListForm() {
statusListRequest.setListForm(null);
void shouldReturn() {
var msgStatusList = getStatusList();
assertThatExceptionOfType(XTAWSTechnicalProblemException.class).isThrownBy(
() -> msgBoxPortImpl.getStatusList(statusListRequest, authorIdentifier, responseHeaderHolder))
.has(technicalProblemErrorCodeCondition());
assertThat(msgStatusList).isEqualTo(statusListType);
}
@DisplayName("should assign header")
@Test
void shouldRejectRequestWithInvalidListForm() {
statusListRequest.setListForm("MsgAttributeListType");
void shouldAssignHeader() {
getStatusList();
assertThatExceptionOfType(XTAWSTechnicalProblemException.class).isThrownBy(
() -> msgBoxPortImpl.getStatusList(statusListRequest, authorIdentifier, responseHeaderHolder))
.has(technicalProblemErrorCodeCondition());
assertThat(msgBoxResponseHeader.value).isEqualTo(mappedMsgBoxResponseHeader);
}
@ParameterizedTest
@ValueSource(longs = { -1, 0, Long.MAX_VALUE})
void shouldRejectRequestWithInvalidMaxListItems(long maxListItems) {
statusListRequest.setMaxListItems(BigInteger.valueOf(maxListItems));
when(xtaIdGenerator.generateRequestId()).thenReturn(REQUEST_ID);
assertThatExceptionOfType(XTAWSTechnicalProblemException.class).isThrownBy(
() -> msgBoxPortImpl.getStatusList(statusListRequest, authorIdentifier, responseHeaderHolder))
.has(technicalProblemErrorCodeCondition());
}
@Test
void shouldReturnStatusList() {
setupMocksForValidRequest();
var msgStatusList = executeGetStatusRequestListWithPossibleException();
var messageMetaDataList = msgStatusList.getMessageMetaData();
@DisplayName("with invalid request")
@Nested
class TestWithInvalidRequest {
assertThat(messageMetaDataList).containsExactly(mappedMessageMetaData);
@BeforeEach
@SneakyThrows
void setup() {
doThrow(new XTAWSTechnicalProblemException()).when(requestValidator).validate(request);
}
@DisplayName("should throw exception")
@Test
void shouldHaveEmptyMsgAttributes() {
setupMocksForValidRequest();
var msgStatusList = executeGetStatusRequestListWithPossibleException();
assertThat(msgStatusList.getMsgAttributes()).isEmpty();
void shouldThrowException() {
assertThatThrownBy(TestGetStatusList.this::getStatusList)
.isInstanceOf(XTAWSTechnicalProblemException.class);
}
@Test
void shouldSetResponseHeader() {
setupMocksForValidRequest();
executeGetStatusRequestListWithPossibleException();
assertThat(responseHeaderHolder.value).isSameAs(mappedMsgBoxResponseHeader);
}
@SneakyThrows
private MsgStatusListType executeGetStatusRequestListWithPossibleException() {
return msgBoxPortImpl.getStatusList(statusListRequest, authorIdentifier, responseHeaderHolder);
private MsgStatusListType getStatusList() {
return msgBoxPortImpl.getStatusList(statusListRequest, authorIdentifier, msgBoxResponseHeader);
}
}
@DisplayName("close")
@Nested
class Close {
class TestClose {
@Mock
private MsgBoxCloseRequestType closeRequest;
@Mock
private PartyType authorIdentifier;
private XtaCloseRequest request;
@BeforeEach
void beforeEach() {
closeRequest = MsgBoxCloseRequestTypeTestFactory.create();
void mock() {
request = XtaCloseRequest.builder()
.messageId(MESSAGE_ID)
.clientIdentifierValue(TestGetMessage.CLIENT_IDENTIFIER_VALUE)
.build();
when(requestMapper.mapXtaCloseRequest(closeRequest, authorIdentifier)).thenReturn(request);
}
@Test
void shouldAcceptValidRequest() {
when(xtaMessageService.closeMessage(MsgBoxCloseRequestTypeTestFactory.MESSAGE_ID.getValue())).thenReturn(true);
assertThatNoException().isThrownBy(() -> msgBoxPortImpl.close(closeRequest, authorIdentifier));
@DisplayName("with valid request")
@Nested
class TestWithValidRequest {
@BeforeEach
void setup() {
when(xtaMessageService.closeMessage(request)).thenReturn(true);
}
@DisplayName("should call close message")
@Test
void shouldCloseMessage() {
when(xtaMessageService.closeMessage(MsgBoxCloseRequestTypeTestFactory.MESSAGE_ID.getValue())).thenReturn(true);
@SneakyThrows
void shouldCallCloseMessage() {
close();
try {
msgBoxPortImpl.close(closeRequest, authorIdentifier);
} catch (Exception e) {
// ignore
verify(xtaMessageService).closeMessage(any());
}
verify(xtaMessageService).closeMessage(MsgBoxCloseRequestTypeTestFactory.MESSAGE_ID.getValue());
@DisplayName("should return")
@Test
void shouldReturn() {
close();
}
}
@DisplayName("with invalid message id")
@Nested
class TestWithInvalidMessageId {
@Mock
private InvalidMessageIDException exception;
@DisplayName("should throw exception")
@Test
void shouldRejectRequestWithUnknownMessageId() {
when(xtaMessageService.closeMessage(any())).thenReturn(false);
void shouldThrowException() {
when(xtaMessageService.closeMessage(request)).thenReturn(false);
when(exceptionMapper.createInvalidMessageIDException(any())).thenReturn(exception);
assertThatExceptionOfType(InvalidMessageIDException.class).isThrownBy(
() -> msgBoxPortImpl.close(closeRequest, authorIdentifier)
).has(invalidMessageIDExceptionCondition());
assertThatThrownBy(TestClose.this::close)
.isEqualTo(exception);
}
}
private Condition<XTAWSTechnicalProblemException> technicalProblemErrorCodeCondition() {
return new Condition<>(e -> e.getFaultInfo().getErrorCode().getCode().equals("9030"), "error code 9030");
@DisplayName("with invalid request")
@Nested
class TestWithInvalidRequest {
@BeforeEach
@SneakyThrows
void setup() {
doThrow(new XTAWSTechnicalProblemException()).when(requestValidator).validate(any());
}
private Condition<InvalidMessageIDException> invalidMessageIDExceptionCondition() {
return new Condition<>(e -> e.getFaultInfo().getErrorCode().getCode().equals("9070"), "error code 9070 for invalid message ID");
@DisplayName("should throw exception")
@Test
void shouldThrowException() {
assertThatThrownBy(TestClose.this::close)
.isInstanceOf(XTAWSTechnicalProblemException.class);
}
}
@SneakyThrows
private void close() {
msgBoxPortImpl.close(closeRequest, authorIdentifier);
}
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

Impressum - Datenschutz - Barrierefreiheit