diff --git a/src/main/java/de/ozgcloud/xta/test/app/data/XtaMessageRepository.java b/src/main/java/de/ozgcloud/xta/test/app/data/XtaMessageRepository.java
index b84e9826039df4c04a2f07f66ed42e992f74c1e3..dc107e5dce765f57da1454afbf07bb461fe14044 100644
--- a/src/main/java/de/ozgcloud/xta/test/app/data/XtaMessageRepository.java
+++ b/src/main/java/de/ozgcloud/xta/test/app/data/XtaMessageRepository.java
@@ -1,20 +1,19 @@
package de.ozgcloud.xta.test.app.data;
-import java.io.IOException;
import java.math.BigInteger;
-import java.nio.file.Files;
+import java.time.ZonedDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Component;
-import de.ozgcloud.xta.test.app.model.XtaFile;
import de.ozgcloud.xta.test.app.model.XtaMessage;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.log4j.Log4j2;
+import de.ozgcloud.xta.test.app.model.XtaTransportReport;
@Component
@Log4j2
@@ -22,53 +21,60 @@ import lombok.extern.log4j.Log4j2;
public class XtaMessageRepository {
private final Map<String, XtaMessage> messages = new HashMap<>();
+ private final HashMap<String, XtaTransportReport.MessageStatus> messageIdToStatus = new HashMap<>();
- public void save(XtaMessage message) {
+ public boolean add(XtaMessage message) {
+ if (messages.containsKey(message.metaData().messageId())) {
+ return false;
+ }
messages.put(message.metaData().messageId(), message);
+ messageIdToStatus.put(message.metaData().messageId(), XtaTransportReport.MessageStatus.OFFEN);
+ return true;
}
- public Optional<XtaMessage> get(String messageId) {
+ public Optional<XtaMessage> getMessage(String messageId) {
return Optional.ofNullable(messages.get(messageId));
}
- public boolean delete(String messageId) {
+ public Optional<XtaTransportReport> getTransportReport(String messageId) {
if (messages.containsKey(messageId)) {
- var message = messages.get(messageId);
- message.attachmentFiles().forEach(this::silentDeleteFile);
- silentDeleteFile(message.messageFile());
- messages.remove(messageId);
- return true;
- }
- return false;
- }
-
- private void silentDeleteFile(XtaFile xtaFile) {
- try {
- Files.delete(xtaFile.file().toPath());
- } catch (IOException e) {
- log.warn("Could not delete file: {}", e.getMessage());
+ return Optional.of(XtaTransportReport.builder()
+ .messageMetaData(messages.get(messageId).metaData())
+ .status(messageIdToStatus.get(messageId))
+ .reportTime(getNow())
+ .build());
}
+ return Optional.empty();
}
- public List<XtaMessage> findByReaderIdentifierValueLimitedTo(String readerIdentifierValue, int maxListItems) {
- return findByReaderIdentifierValue(readerIdentifierValue)
+ public List<XtaMessage> findOpenMessagesByReaderIdentifierValueLimitedTo(String readerIdentifierValue, int maxListItems) {
+ return findOpenMessagesByReaderIdentifierValue(readerIdentifierValue)
.limit(maxListItems)
.toList();
}
- public BigInteger countByReaderIdentifierValue(String readerIdentifierValue) {
- return BigInteger.valueOf(findByReaderIdentifierValue(readerIdentifierValue).count());
+ public BigInteger countOpenMessagesByReaderIdentifierValue(String readerIdentifierValue) {
+ return BigInteger.valueOf(findOpenMessagesByReaderIdentifierValue(readerIdentifierValue).count());
}
- Stream<XtaMessage> findByReaderIdentifierValue(String readerIdentifierValue) {
+ Stream<XtaMessage> findOpenMessagesByReaderIdentifierValue(String readerIdentifierValue) {
return messages.values().stream()
+ .filter(m -> messageIdToStatus.get(m.metaData().messageId()) == XtaTransportReport.MessageStatus.OFFEN)
.filter(m -> m.metaData().readerIdentifier().value().equals(readerIdentifierValue));
}
- public boolean deleteByMessageIdAndReaderIdentifierValue(String messageId, String readerIdentifierValue) {
- return get(messageId)
+ public boolean closeByMessageIdAndReaderIdentifierValue(String messageId, String readerIdentifierValue) {
+ return getMessage(messageId)
.filter(m -> m.metaData().readerIdentifier().value().equals(readerIdentifierValue))
- .map(m -> delete(messageId))
+ .map(m -> close(messageId))
.orElse(false);
}
+
+ boolean close(String messageId) {
+ return messageIdToStatus.computeIfPresent(messageId, (k, v) -> XtaTransportReport.MessageStatus.GRUEN) != null;
+ }
+
+ private ZonedDateTime getNow() {
+ return ZonedDateTime.now();
+ }
}
diff --git a/src/main/java/de/ozgcloud/xta/test/app/data/XtaTransportReportRepository.java b/src/main/java/de/ozgcloud/xta/test/app/data/XtaTransportReportRepository.java
deleted file mode 100644
index 4d86cd3bac5b110a98246c7caeb34bc37db19869..0000000000000000000000000000000000000000
--- a/src/main/java/de/ozgcloud/xta/test/app/data/XtaTransportReportRepository.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package de.ozgcloud.xta.test.app.data;
-
-import java.time.ZonedDateTime;
-import java.util.HashMap;
-import java.util.Optional;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Component;
-
-import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
-import de.ozgcloud.xta.test.app.model.XtaTransportReport;
-
-@Component
-@RequiredArgsConstructor
-public class XtaTransportReportRepository {
- private final HashMap<String, XtaMessageMetaData> messageIdTomessageMetaData = new HashMap<>();
- private final HashMap<String, XtaTransportReport.MessageStatus> messageIdToStatus = new HashMap<>();
-
- public boolean add(XtaMessageMetaData messageMetaData) {
- if (messageIdTomessageMetaData.containsKey(messageMetaData.messageId())) {
- return false;
- }
- messageIdTomessageMetaData.put(messageMetaData.messageId(), messageMetaData);
- messageIdToStatus.put(messageMetaData.messageId(), XtaTransportReport.MessageStatus.OFFEN);
- return true;
- }
-
- public boolean setClosedStatus(String messageId) {
- if (!messageIdToStatus.containsKey(messageId)) {
- return false;
- }
-
- messageIdToStatus.put(messageId, XtaTransportReport.MessageStatus.GRUEN);
- return true;
-
- }
-
- public Optional<XtaTransportReport> get(String messageId) {
- if (messageIdTomessageMetaData.containsKey(messageId)) {
- return Optional.of(XtaTransportReport.builder()
- .messageMetaData(messageIdTomessageMetaData.get(messageId))
- .status(messageIdToStatus.get(messageId))
- .reportTime(getNow())
- .build());
- }
- return Optional.empty();
- }
-
- private ZonedDateTime getNow() {
- return ZonedDateTime.now();
- }
-}
diff --git a/src/main/java/de/ozgcloud/xta/test/app/service/XtaMessageService.java b/src/main/java/de/ozgcloud/xta/test/app/service/XtaMessageService.java
index 2d663d603bd703c2cad6b1a5f5f604711ad17fd0..201c5a90afdc563273c3e4e125f68a0ac4df659a 100644
--- a/src/main/java/de/ozgcloud/xta/test/app/service/XtaMessageService.java
+++ b/src/main/java/de/ozgcloud/xta/test/app/service/XtaMessageService.java
@@ -9,7 +9,6 @@ import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;
import de.ozgcloud.xta.test.app.data.XtaMessageRepository;
-import de.ozgcloud.xta.test.app.data.XtaTransportReportRepository;
import de.ozgcloud.xta.test.app.model.*;
import lombok.RequiredArgsConstructor;
@@ -18,22 +17,17 @@ import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
public class XtaMessageService {
private final XtaMessageRepository messageRepository;
- private final XtaTransportReportRepository transportReportRepository;
private final Environment environment;
public boolean sendMessage(XtaMessage message) {
- if (transportReportRepository.add(message.metaData())) {
- messageRepository.save(message);
- return true;
- }
- return false;
+ return messageRepository.add(message);
}
public XtaMessageMetaDataListing getStatusList(XtaMessageMetaDataListingRequest listingRequest) {
return XtaMessageMetaDataListing.builder()
- .pendingMessageCount(messageRepository.countByReaderIdentifierValue(listingRequest.clientIdentifier().value()))
- .messages(getMetaData(messageRepository.findByReaderIdentifierValueLimitedTo(
+ .pendingMessageCount(messageRepository.countOpenMessagesByReaderIdentifierValue(listingRequest.clientIdentifier().value()))
+ .messages(getMetaData(messageRepository.findOpenMessagesByReaderIdentifierValueLimitedTo(
listingRequest.clientIdentifier().value(),
listingRequest.maxListItems())))
.build();
@@ -46,7 +40,7 @@ public class XtaMessageService {
}
public Optional<XtaMessage> getMessage(XtaGetMessageRequest request) {
- return messageRepository.get(request.messageId())
+ return messageRepository.getMessage(request.messageId())
.filter(isAuthorOrReaderOfMessage(request.clientIdentifier().value()));
}
@@ -55,16 +49,14 @@ public class XtaMessageService {
}
public boolean closeMessage(XtaCloseRequest request) {
- var isDeleted = messageRepository.deleteByMessageIdAndReaderIdentifierValue(
+ return messageRepository.closeByMessageIdAndReaderIdentifierValue(
request.messageId(),
request.clientIdentifier().value()
);
- var isClosed = transportReportRepository.setClosedStatus(request.messageId());
- return isDeleted && isClosed;
}
public Optional<XtaTransportReport> getTransportReport(XtaGetTransportReportRequest request) {
- return transportReportRepository.get(request.messageId())
+ return messageRepository.getTransportReport(request.messageId())
.filter(isAuthorOrReaderOfTransportReport(request.clientIdentifier().value()));
}
diff --git a/src/test/java/de/ozgcloud/xta/test/app/data/XtaMessageRepositoryTest.java b/src/test/java/de/ozgcloud/xta/test/app/data/XtaMessageRepositoryTest.java
index af7fe1a6223ca4bac704049b2f28896fae44bf42..e48a5aace20088c243c99f8f66ff33a05ce45ada 100644
--- a/src/test/java/de/ozgcloud/xta/test/app/data/XtaMessageRepositoryTest.java
+++ b/src/test/java/de/ozgcloud/xta/test/app/data/XtaMessageRepositoryTest.java
@@ -1,11 +1,11 @@
package de.ozgcloud.xta.test.app.data;
-import static de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory.*;
-import static de.ozgcloud.xta.test.app.factory.XtaMessageTestFactory.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import static de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory.READER_IDENTIFIER;
+import static de.ozgcloud.xta.test.app.factory.XtaMessageTestFactory.MESSAGE_ID_1;
+import static de.ozgcloud.xta.test.app.factory.XtaMessageTestFactory.MESSAGE_ID_2;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.doReturn;
-import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.api.BeforeEach;
@@ -17,18 +17,18 @@ import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.InjectMocks;
import org.mockito.Spy;
-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.XtaFile;
import de.ozgcloud.xta.test.app.model.XtaIdentifier;
import de.ozgcloud.xta.test.app.model.XtaMessage;
+import de.ozgcloud.xta.test.app.model.XtaTransportReport;
public class XtaMessageRepositoryTest {
@Spy
@InjectMocks
private XtaMessageRepository xtaMessageRepository;
+ private final XtaMessage message = XtaMessageTestFactory.create(MESSAGE_ID_1);
@DisplayName("save")
@Nested
@@ -36,101 +36,181 @@ public class XtaMessageRepositoryTest {
@Test
void shouldSaveMessage() {
- var message = XtaMessageTestFactory.create(MESSAGE_ID_1);
+ xtaMessageRepository.add(message);
- xtaMessageRepository.save(message);
-
- assertThat(xtaMessageRepository.get(MESSAGE_ID_1)).contains(message);
+ assertThat(xtaMessageRepository.getMessage(MESSAGE_ID_1)).contains(message);
}
}
- @DisplayName("get")
+ @DisplayName("get message")
@Nested
- class TestGet {
- private final XtaMessage message = XtaMessageTestFactory.create(MESSAGE_ID_1);
-
+ class TestGetMessage {
@BeforeEach
void beforeEach() {
xtaMessageRepository = new XtaMessageRepository();
- xtaMessageRepository.save(message);
+ xtaMessageRepository.add(message);
}
@Test
void shouldReturnMessage() {
- var result = xtaMessageRepository.get(MESSAGE_ID_1);
+ var result = xtaMessageRepository.getMessage(MESSAGE_ID_1);
assertThat(result).contains(message);
}
@Test
void shouldReturnEmpty() {
- var result = xtaMessageRepository.get(MESSAGE_ID_2);
+ var result = xtaMessageRepository.getMessage(MESSAGE_ID_2);
assertThat(result).isEmpty();
}
}
+ @DisplayName("get transport report")
@Nested
- class TestDelete {
- public static final String MESSAGE_ID = "messageId";
- private XtaFile messageFile;
- private XtaFile attachmentFile;
+ class TestGetTransportReport {
+ @Nested
+ class WithExistingMessageId {
+ @BeforeEach
+ void beforeEach() {
+ xtaMessageRepository = new XtaMessageRepository();
+ xtaMessageRepository.add(message);
+ }
+
+ @Test
+ void shouldReturnReport() {
+ var result = xtaMessageRepository.getTransportReport(message.metaData().messageId());
+
+ assertThat(result).isPresent();
+ assertThat(result.get().messageMetaData()).isEqualTo(message.metaData());
+ }
+
+ @Test
+ void shouldSetReportTime() {
+ var result = xtaMessageRepository.getTransportReport(message.metaData().messageId());
+
+ assertThat(result).isPresent();
+ assertThat(result.get().reportTime()).isNotNull();
+ }
+
+ @Test
+ void shouldSetStatusOffen() {
+ var result = xtaMessageRepository.getTransportReport(message.metaData().messageId());
+
+ assertThat(result).isPresent();
+ assertThat(result.get().status()).isEqualTo(XtaTransportReport.MessageStatus.OFFEN);
+ }
+ }
+ @Nested
+ class WithMissingMessageId {
+ @Test
+ void shouldReturnEmpty() {
+ var result = xtaMessageRepository.getTransportReport(message.metaData().messageId());
+
+ assertThat(result).isEmpty();
+ }
+ }
+
+ }
+
+ @DisplayName("close by message id and reader identifier value")
+ @Nested
+ class TestCloseByMessageIdAndReaderIdentifierValue {
@BeforeEach
void beforeEach() {
- messageFile = XtaFileTestFactory.create();
- attachmentFile = XtaFileTestFactory.create();
- var message = XtaMessageTestFactory.createBuilder(MESSAGE_ID)
- .messageFile(messageFile)
- .attachmentFiles(List.of(attachmentFile))
- .build();
- xtaMessageRepository.save(message);
+ xtaMessageRepository = new XtaMessageRepository();
+ xtaMessageRepository.add(message);
}
@Test
- void shouldDeleteMessage() {
- xtaMessageRepository.delete(MESSAGE_ID);
+ void shouldCloseMessage() {
+ var result = xtaMessageRepository.closeByMessageIdAndReaderIdentifierValue(message.metaData().messageId(),
+ message.metaData().readerIdentifier().value());
- assertThat(xtaMessageRepository.get(MESSAGE_ID)).isEmpty();
+ assertThat(result).isTrue();
}
@Test
- void shouldDeleteTemporaryFiles() {
- assertThat(messageFile.file()).exists();
- assertThat(attachmentFile.file()).exists();
+ void shouldNotCloseMessageWithUnknownReaderIdentifier() {
+ var result = xtaMessageRepository.closeByMessageIdAndReaderIdentifierValue(message.metaData().messageId(), "unknown");
- xtaMessageRepository.delete(MESSAGE_ID);
+ assertThat(result).isFalse();
+ }
- assertThat(messageFile.file()).doesNotExist();
- assertThat(attachmentFile.file()).doesNotExist();
+ @Test
+ void shouldNotCloseMessageWithModifiedMessageId() {
+ var result = xtaMessageRepository.closeByMessageIdAndReaderIdentifierValue(message.metaData().messageId() + "1",
+ message.metaData().readerIdentifier().value());
+
+ assertThat(result).isFalse();
}
}
- @DisplayName("find by reader identifier value limited to")
+ @DisplayName("close")
+ @Nested
+ class TestClose {
+ @BeforeEach
+ void beforeEach() {
+ xtaMessageRepository = new XtaMessageRepository();
+ }
+
+ @Test
+ void shouldSetClosedStatus() {
+ xtaMessageRepository.add(message);
+
+ xtaMessageRepository.close(message.metaData().messageId());
+ var report = xtaMessageRepository.getTransportReport(message.metaData().messageId());
+
+ assertThat(report).isPresent();
+ assertThat(report.get().status()).isEqualTo(XtaTransportReport.MessageStatus.GRUEN);
+ }
+
+ @Test
+ void shouldReturnTrueOnSuccess() {
+ xtaMessageRepository.add(message);
+
+ var result = xtaMessageRepository.close(message.metaData().messageId());
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ void shouldReturnFalseOnMissingMessageId() {
+ var result = xtaMessageRepository.close(message.metaData().messageId());
+
+ assertThat(result).isFalse();
+ }
+
+ }
+
+ @DisplayName("find open messages by reader identifier value limited to")
@Nested
- class TestFindByReaderIdentifierValueLimitedTo {
+ class TestFindOpenMessagesByReaderIdentifierValueLimitedTo {
@BeforeEach
void beforeEach() {
- xtaMessageRepository.save(XtaMessageTestFactory.create("1"));
- xtaMessageRepository.save(XtaMessageTestFactory.create("2"));
- xtaMessageRepository.save(XtaMessageTestFactory.create("3"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("1"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("2"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("3"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("4"));
+ xtaMessageRepository.close("4");
}
@DisplayName("should return limit")
@ParameterizedTest
@ValueSource(ints = { 0, 1, 2 })
void shouldReturnLimit(int limit) {
- var result = xtaMessageRepository.findByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), limit);
+ var result = xtaMessageRepository.findOpenMessagesByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), limit);
assertThat(result).hasSize(limit);
}
- @DisplayName("should return all")
+ @DisplayName("should return all open messages")
@ParameterizedTest
@ValueSource(ints = { 3, 4, 5 })
- void shouldReturnAll(int limit) {
- var result = xtaMessageRepository.findByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), limit);
+ void shouldReturnAllOpenMessages(int limit) {
+ var result = xtaMessageRepository.findOpenMessagesByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), limit);
assertThat(result).hasSize(3);
}
@@ -138,44 +218,46 @@ public class XtaMessageRepositoryTest {
@DisplayName("should not find any with unknown reader identifier")
@Test
void shouldNotFindAnyWithUnknownReaderIdentifier() {
- var result = xtaMessageRepository.findByReaderIdentifierValueLimitedTo("unknown", 1);
+ var result = xtaMessageRepository.findOpenMessagesByReaderIdentifierValueLimitedTo("unknown", 1);
assertThat(result).isEmpty();
}
}
- @DisplayName("count by reader identifier value")
+ @DisplayName("count open messages by reader identifier value")
@Nested
- class TestCountByReaderIdentifierValue {
+ class TestCountOpenMessagesByReaderIdentifierValue {
@BeforeEach
void beforeEach() {
doReturn(Stream.of(XtaMessageTestFactory.create("1"), XtaMessageTestFactory.create("2"),
- XtaMessageTestFactory.create("3"))).when(xtaMessageRepository).findByReaderIdentifierValue(READER_IDENTIFIER.value());
+ XtaMessageTestFactory.create("3"))).when(xtaMessageRepository).findOpenMessagesByReaderIdentifierValue(READER_IDENTIFIER.value());
}
@DisplayName("should return")
@Test
void shouldReturn() {
- var count = xtaMessageRepository.countByReaderIdentifierValue(READER_IDENTIFIER.value());
+ var count = xtaMessageRepository.countOpenMessagesByReaderIdentifierValue(READER_IDENTIFIER.value());
assertThat(count).isEqualTo(3);
}
}
- @DisplayName("find by reader identifier value")
+ @DisplayName("find open messages by reader identifier value")
@Nested
- class TestFindByReaderIdentifierValue {
+ class TestFindOpenMessagesByReaderIdentifierValue {
private static final String OTHER_READER_IDENTIFIER = "readerIdentifier";
@BeforeEach
void beforeEach() {
xtaMessageRepository = new XtaMessageRepository();
- xtaMessageRepository.save(XtaMessageTestFactory.create("1"));
- xtaMessageRepository.save(XtaMessageTestFactory.create("2"));
- xtaMessageRepository.save(XtaMessageTestFactory.create("3"));
- xtaMessageRepository.save(XtaMessageTestFactory.createBuilder()
+ xtaMessageRepository.add(XtaMessageTestFactory.create("1"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("2"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("3"));
+ xtaMessageRepository.add(XtaMessageTestFactory.create("4"));
+ xtaMessageRepository.close("4");
+ xtaMessageRepository.add(XtaMessageTestFactory.createBuilder()
.metaData(XtaMessageMetaDataTestFactory.createBuilder()
.readerIdentifier(XtaIdentifier.builder().value(OTHER_READER_IDENTIFIER).build())
.build())
@@ -185,7 +267,7 @@ public class XtaMessageRepositoryTest {
@DisplayName("should return message for reader identifier")
@Test
void shouldReturnMessageForReaderIdentifier() {
- var result = xtaMessageRepository.findByReaderIdentifierValue(READER_IDENTIFIER.value()).toList();
+ var result = xtaMessageRepository.findOpenMessagesByReaderIdentifierValue(READER_IDENTIFIER.value()).toList();
assertThat(result).hasSize(3);
}
@@ -193,7 +275,7 @@ public class XtaMessageRepositoryTest {
@DisplayName("should return messages for other reader identifier")
@Test
void shouldReturnMessagesForOtherReaderIdentifier() {
- var result = xtaMessageRepository.findByReaderIdentifierValue(OTHER_READER_IDENTIFIER).toList();
+ var result = xtaMessageRepository.findOpenMessagesByReaderIdentifierValue(OTHER_READER_IDENTIFIER).toList();
assertThat(result).hasSize(1);
}
@@ -201,7 +283,7 @@ public class XtaMessageRepositoryTest {
@DisplayName("should return no messages for unknown reader identifier")
@Test
void shouldReturnNoMessagesForUnknownReaderIdentifier() {
- var result = xtaMessageRepository.findByReaderIdentifierValue("unknown").toList();
+ var result = xtaMessageRepository.findOpenMessagesByReaderIdentifierValue("unknown").toList();
assertThat(result).isEmpty();
}
diff --git a/src/test/java/de/ozgcloud/xta/test/app/data/XtaTransportReportRepositoryTest.java b/src/test/java/de/ozgcloud/xta/test/app/data/XtaTransportReportRepositoryTest.java
deleted file mode 100644
index 2eb7701f1d7d575d2eb266a8897e1aeaf9e89210..0000000000000000000000000000000000000000
--- a/src/test/java/de/ozgcloud/xta/test/app/data/XtaTransportReportRepositoryTest.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package de.ozgcloud.xta.test.app.data;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.mockito.Spy;
-
-import de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory;
-import de.ozgcloud.xta.test.app.model.XtaMessageMetaData;
-import de.ozgcloud.xta.test.app.model.XtaTransportReport;
-
-public class XtaTransportReportRepositoryTest {
- @Spy
- private XtaTransportReportRepository repository;
-
- private final XtaMessageMetaData messageMetaData = XtaMessageMetaDataTestFactory.create();
-
- @Nested
- class Add{
- @Test
- void shouldReturnTrue() {
- var result = repository.add(messageMetaData);
-
- assertThat(result).isTrue();
- }
-
- @Test
- void shouldReturnFalseForDuplicateMessageId() {
- repository.add(messageMetaData);
- var result = repository.add(messageMetaData);
-
- assertThat(result).isFalse();
- }
-
- }
-
- @Nested
- class Get {
- @Nested
- class WithExistingMessageId {
- @Test
- void shouldReturnReport() {
- repository.add(messageMetaData);
-
- var result = repository.get(messageMetaData.messageId());
-
- assertThat(result).isPresent();
- assertThat(result.get().messageMetaData()).isEqualTo(messageMetaData);
- }
-
- @Test
- void shouldSetReportTime() {
- repository.add(messageMetaData);
-
- var result = repository.get(messageMetaData.messageId());
-
- assertThat(result).isPresent();
- assertThat(result.get().reportTime()).isNotNull();
- }
-
- @Test
- void shouldSetStatusOffen() {
- repository.add(messageMetaData);
-
- var result = repository.get(messageMetaData.messageId());
-
- assertThat(result).isPresent();
- assertThat(result.get().status()).isEqualTo(XtaTransportReport.MessageStatus.OFFEN);
- }
- }
-
- @Nested
- class WithMissingMessageId {
- @Test
- void shouldReturnEmpty() {
- var result = repository.get(messageMetaData.messageId());
-
- assertThat(result).isEmpty();
- }
- }
-
- }
-
- @Nested
- class SetClosedStatus {
- @Test
- void shouldSetClosedStatus() {
- repository.add(messageMetaData);
-
- repository.setClosedStatus(messageMetaData.messageId());
- var report = repository.get(messageMetaData.messageId());
-
- assertThat(report).isPresent();
- assertThat(report.get().status()).isEqualTo(XtaTransportReport.MessageStatus.GRUEN);
- }
-
- @Test
- void shouldReturnTrueOnSuccess() {
- repository.add(messageMetaData);
-
- var result = repository.setClosedStatus(messageMetaData.messageId());
-
- assertThat(result).isTrue();
- }
-
- @Test
- void shouldReturnFalseOnMissingMessageId() {
- var result = repository.setClosedStatus(messageMetaData.messageId());
-
- assertThat(result).isFalse();
- }
-
- }
-}
diff --git a/src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageServiceTest.java b/src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageServiceTest.java
index ff75022fd71553d543e318141972ab35824ba3a6..08acdb49bfacd8fb56250383cc654b6a3404e062 100644
--- a/src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageServiceTest.java
+++ b/src/test/java/de/ozgcloud/xta/test/app/service/XtaMessageServiceTest.java
@@ -23,7 +23,6 @@ import org.mockito.Spy;
import org.springframework.core.env.Environment;
import de.ozgcloud.xta.test.app.data.XtaMessageRepository;
-import de.ozgcloud.xta.test.app.data.XtaTransportReportRepository;
import de.ozgcloud.xta.test.app.factory.XtaCloseRequestTestFactory;
import de.ozgcloud.xta.test.app.factory.XtaMessageMetaDataTestFactory;
import de.ozgcloud.xta.test.app.factory.XtaMessageTestFactory;
@@ -33,8 +32,6 @@ public class XtaMessageServiceTest {
@Mock
private XtaMessageRepository messageRepository;
@Mock
- private XtaTransportReportRepository transportReportRepository;
- @Mock
private Environment environment;
@Spy
@@ -51,23 +48,13 @@ public class XtaMessageServiceTest {
message = XtaMessageTestFactory.create(MESSAGE_ID);
}
- @Test
- void shouldSaveTransportReport() {
- message = XtaMessageTestFactory.create(MESSAGE_ID);
-
- service.sendMessage(message);
-
- verify(transportReportRepository).add(message.metaData());
- }
-
@Test
void shouldSaveMessage() {
- when(transportReportRepository.add(message.metaData())).thenReturn(true);
message = XtaMessageTestFactory.create(MESSAGE_ID);
service.sendMessage(message);
- verify(messageRepository).save(message);
+ verify(messageRepository).add(message);
}
}
@@ -90,9 +77,9 @@ public class XtaMessageServiceTest {
message1 = XtaMessageTestFactory.create(MESSAGE_ID_1);
message2 = XtaMessageTestFactory.create(MESSAGE_ID_2);
- when(messageRepository.findByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), MAX_LIST_ITEMS)).thenReturn(
+ when(messageRepository.findOpenMessagesByReaderIdentifierValueLimitedTo(READER_IDENTIFIER.value(), MAX_LIST_ITEMS)).thenReturn(
List.of(message1, message2));
- when(messageRepository.countByReaderIdentifierValue(READER_IDENTIFIER.value())).thenReturn(BigInteger.valueOf(MESSAGE_COUNT));
+ when(messageRepository.countOpenMessagesByReaderIdentifierValue(READER_IDENTIFIER.value())).thenReturn(BigInteger.valueOf(MESSAGE_COUNT));
}
@Test
@@ -131,7 +118,7 @@ public class XtaMessageServiceTest {
@DisplayName("should return")
@Test
void shouldReturn() {
- when(messageRepository.get(MESSAGE_ID_1)).thenReturn(Optional.of(message));
+ when(messageRepository.getMessage(MESSAGE_ID_1)).thenReturn(Optional.of(message));
doReturn(IS_AUTHOR_OR_READER).when(service).isAuthorOrReaderOfMessage(READER_IDENTIFIER.value());
var result = service.getMessage(GET_MESSAGE_REQUEST);
@@ -142,7 +129,7 @@ public class XtaMessageServiceTest {
@DisplayName("should return empty if message id not found")
@Test
void shouldReturnEmptyIfMessageIdNotFound() {
- when(messageRepository.get(MESSAGE_ID_1)).thenReturn(Optional.empty());
+ when(messageRepository.getMessage(MESSAGE_ID_1)).thenReturn(Optional.empty());
var result = service.getMessage(GET_MESSAGE_REQUEST);
@@ -152,7 +139,7 @@ public class XtaMessageServiceTest {
@DisplayName("should return empty if not author or reader")
@Test
void shouldReturnEmptyIfNotAuthorOrReader() {
- when(messageRepository.get(MESSAGE_ID_1)).thenReturn(Optional.of(message));
+ when(messageRepository.getMessage(MESSAGE_ID_1)).thenReturn(Optional.of(message));
doReturn(IS_NOT_AUTHOR_OR_READER).when(service).isAuthorOrReaderOfMessage(READER_IDENTIFIER.value());
var result = service.getMessage(GET_MESSAGE_REQUEST);
@@ -230,16 +217,14 @@ public class XtaMessageServiceTest {
@DisplayName("should return")
@ParameterizedTest
@ValueSource(booleans = { true, false })
- void shouldReturn(boolean deleted) {
+ void shouldReturn(boolean closed) {
var request = XtaCloseRequestTestFactory.create();
- when(messageRepository.deleteByMessageIdAndReaderIdentifierValue(
- request.messageId(), request.clientIdentifier().value())
- ).thenReturn(deleted);
- when(transportReportRepository.setClosedStatus(request.messageId())).thenReturn(deleted);
+ when(messageRepository.closeByMessageIdAndReaderIdentifierValue(request.messageId(), request.clientIdentifier().value()))
+ .thenReturn(closed);
boolean result = service.closeMessage(request);
- assertThat(result).isEqualTo(deleted);
+ assertThat(result).isEqualTo(closed);
}
@DisplayName("should set transport status to closed")
@@ -249,7 +234,7 @@ public class XtaMessageServiceTest {
service.closeMessage(request);
- verify(transportReportRepository).setClosedStatus(request.messageId());
+ verify(messageRepository).closeByMessageIdAndReaderIdentifierValue(request.messageId(), request.clientIdentifier().value());
}
}
@@ -268,7 +253,7 @@ public class XtaMessageServiceTest {
@DisplayName("should return")
@Test
void shouldReturn() {
- when(transportReportRepository.get(MESSAGE_ID_1)).thenReturn(Optional.of(report));
+ when(messageRepository.getTransportReport(MESSAGE_ID_1)).thenReturn(Optional.of(report));
doReturn(IS_AUTHOR_OR_READER).when(service).isAuthorOrReaderOfTransportReport(READER_IDENTIFIER.value());
var result = service.getTransportReport(GET_TRANSPORT_REPORT_REQUEST);
@@ -279,7 +264,7 @@ public class XtaMessageServiceTest {
@DisplayName("should return empty if message id not found")
@Test
void shouldReturnEmptyIfMessageIdNotFound() {
- when(transportReportRepository.get(MESSAGE_ID_1)).thenReturn(Optional.empty());
+ when(messageRepository.getTransportReport(MESSAGE_ID_1)).thenReturn(Optional.empty());
var result = service.getTransportReport(GET_TRANSPORT_REPORT_REQUEST);
@@ -289,7 +274,7 @@ public class XtaMessageServiceTest {
@DisplayName("should return empty if not author or reader")
@Test
void shouldReturnEmptyIfNotAuthorOrReader() {
- when(transportReportRepository.get(MESSAGE_ID_1)).thenReturn(Optional.of(report));
+ when(messageRepository.getTransportReport(MESSAGE_ID_1)).thenReturn(Optional.of(report));
doReturn(IS_NOT_AUTHOR_OR_READER).when(service).isAuthorOrReaderOfTransportReport(READER_IDENTIFIER.value());
var result = service.getTransportReport(GET_TRANSPORT_REPORT_REQUEST);