diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java
index 0d576aabd573e0bce86a53334a0914068b0a842a..f0c954007b2aabfa4ed9c3af1e3a3499bb323a04 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java
@@ -84,6 +84,7 @@ interface AntragraumNachrichtMapper {
return ZonedDateTime.parse(sentAt);
}
+ @Mapping(target = "sentAtBytes", ignore = true)
@Mapping(target = "mergeFrom", ignore = true)
@Mapping(target = "clearField", ignore = true)
@Mapping(target = "clearOneof", ignore = true)
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/NachrichtId.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/NachrichtId.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbba4ee93f6c56f350c6968a78f122b5231e8477
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/NachrichtId.java
@@ -0,0 +1,17 @@
+package de.ozgcloud.nachrichten.postfach;
+
+import org.mapstruct.ObjectFactory;
+
+import de.ozgcloud.common.datatype.StringBasedValue;
+
+class NachrichtId extends StringBasedValue {
+
+ NachrichtId(String vorgangId) {
+ super(vorgangId);
+ }
+
+ @ObjectFactory
+ public static NachrichtId from(String vorgangId) {
+ return new NachrichtId(vorgangId);
+ }
+}
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java
index 260983f3386173286bddb7641b19d7ab1e7b8df6..154404a4d8c7fb71f22e51016e004f8f63a0f5d6 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java
@@ -29,7 +29,7 @@ import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;
-import org.apache.commons.codec.binary.StringUtils;
+import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
@@ -37,19 +37,24 @@ import org.springframework.stereotype.Service;
import de.ozgcloud.apilib.common.command.OzgCloudCommand;
import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
+import de.ozgcloud.apilib.user.OzgCloudUserId;
import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
import de.ozgcloud.nachrichten.NachrichtenManagerConfiguration;
+import de.ozgcloud.nachrichten.attributes.ClientAttributeService;
import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht.Direction;
@Service
@Primary
public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachrichtService {
private static final String NOT_IMPLEMENTED_MESSAGE = "Not implemented. Use gRPC API instead.";
+
static final String CLIENT = "OzgCloud_NachrichtenManager";
static final String ITEM_NAME = "PostfachMail";
static final String CREATE_ATTACHED_ITEM_ORDER = "CREATE_ATTACHED_ITEM";
+ static final String UPDATE_ATTACHED_ITEM_ORDER = "UPDATE_ATTACHED_ITEM";
static final String CLIENT_FIELD = "client";
static final String VORGANG_ID_FIELD = "vorgangId";
@@ -68,6 +73,8 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
private AttachedItemRemoteService attachedItemRemoteService;
@Autowired
private PostfachNachrichtMapper postfachNachrichtMapper;
+ @Autowired
+ private ClientAttributeService clientAttributeService;
@Autowired(required = false)
@Qualifier("persistPostfachNachrichtByCommandService")
@@ -75,11 +82,75 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
@Override
public void persistNachricht(Optional<String> userId, PostfachNachricht nachricht) {
- if (vorgangManagerNachrichtService != null) {
- vorgangManagerNachrichtService.persistNachricht(userId, nachricht);
- return;
+ commandService.create(buildNachrichtCommand(userId, nachricht));
+
+ setHasNewPostfachNachricht(nachricht);
+ }
+
+ OzgCloudCommand buildNachrichtCommand(Optional<String> userId, PostfachNachricht nachricht) {
+ return StringUtils.isBlank(nachricht.getId()) ? buildCreateCommand(userId, nachricht) : buildUpdateCommand(userId, nachricht);
+ }
+
+ OzgCloudCommand buildUpdateCommand(Optional<String> userId, PostfachNachricht nachricht) {
+ return createBaseCommandBuilder(userId, nachricht)
+ .order(UPDATE_ATTACHED_ITEM_ORDER)
+ .relationId(NachrichtId.from(nachricht.getId()))
+ .bodyObject(buildUpdateItem(nachricht))
+ .build();
+ }
+
+ private Map<String, Object> buildUpdateItem(PostfachNachricht nachricht) {
+ return Map.of(
+ CLIENT_FIELD, CLIENT,
+ ITEM_FIELD, postfachNachrichtMapper.mapToMap(nachricht));
+ }
+
+ // TODO pruefen ob referencedNachricht existiert
+ // TODO pruefen ob referencedNachricht in dem postfach des anfragenden liegt
+ @Override
+ public String persistAnswer(String referencedNachrichtId, PostfachNachricht answer) {
+ var enhancedAnswer = answer.toBuilder().referencedNachricht(referencedNachrichtId).build();
+ var command = buildCreateCommand(Optional.ofNullable(answer.getCreatedBy()), enhancedAnswer);
+
+ var commandId = commandService.create(command).getId().toString();
+
+ setHasNewPostfachNachricht(answer);
+
+ return commandId;
+ }
+
+ OzgCloudCommand buildCreateCommand(Optional<String> userId, PostfachNachricht nachricht) {
+ return createBaseCommandBuilder(userId, nachricht)
+ .order(CREATE_ATTACHED_ITEM_ORDER)
+ .relationId(OzgCloudVorgangId.from(nachricht.getVorgangId()))
+ .bodyObject(buildCreateItem(nachricht))
+ .build();
+ }
+
+ OzgCloudCommand.OzgCloudCommandBuilder createBaseCommandBuilder(Optional<String> userId, PostfachNachricht nachricht) {
+ var commandBuilder = OzgCloudCommand.builder().vorgangId(OzgCloudVorgangId.from(nachricht.getVorgangId()));
+
+ userId.map(OzgCloudUserId::from).ifPresent(commandBuilder::createdBy);
+
+ return commandBuilder;
+ }
+
+ Map<String, Object> buildCreateItem(PostfachNachricht nachricht) {
+ return Map.of(
+ CLIENT_FIELD, CLIENT,
+ VORGANG_ID_FIELD, nachricht.getVorgangId(),
+ ITEM_NAME_FIELD, ITEM_NAME,
+ ITEM_FIELD, postfachNachrichtMapper.mapToMap(nachricht));
+ }
+
+ void setHasNewPostfachNachricht(PostfachNachricht nachricht) {
+ if (isIncomingNachricht(nachricht)) {
+ clientAttributeService.setHasNewPostfachNachricht(nachricht.getVorgangId());
}
- throw new UnsupportedOperationException(NOT_IMPLEMENTED_MESSAGE);
+ }
+
+ private boolean isIncomingNachricht(PostfachNachricht nachricht) {
+ return nachricht.getDirection() == Direction.IN;
}
@Override
@@ -129,33 +200,6 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
.flatMap(attachedItemRemoteService::findReplyAllowedPostfachNachrichts);
}
- // TODO pruefen ob referencedNachricht existiert
- // TODO pruefen ob referencedNachricht in dem postfach des anfragenden liegt
- @Override
- public String persistAnswer(String referencedNachrichtId, PostfachNachricht answer) {
- return commandService.create(buildCommand(setReferencedNachricht(referencedNachrichtId, answer))).getId().toString();
- }
-
- private PostfachNachricht setReferencedNachricht(String referencedNachrichtId, PostfachNachricht answer) {
- return answer.toBuilder().referencedNachricht(referencedNachrichtId).build();
- }
-
- OzgCloudCommand buildCommand(PostfachNachricht nachricht) {
- return OzgCloudCommand.builder().order(CREATE_ATTACHED_ITEM_ORDER)
- .vorgangId(OzgCloudVorgangId.from(nachricht.getVorgangId()))
- .relationId(OzgCloudVorgangId.from(nachricht.getVorgangId()))
- .bodyObject(buildCommandBody(nachricht))
- .build();
- }
-
- Map<String, Object> buildCommandBody(PostfachNachricht nachricht) {
- return Map.of(
- CLIENT_FIELD, CLIENT,
- VORGANG_ID_FIELD, nachricht.getVorgangId(),
- ITEM_NAME_FIELD, ITEM_NAME,
- ITEM_FIELD, postfachNachrichtMapper.mapToMap(nachricht));
- }
-
@Override
public Stream<PostfachNachricht> findAnswers(String serviceKontoType, String postfachId, String rueckfrageId) {
return findPostfachNachricht(serviceKontoType, postfachId)
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java
index c2783a9fbe16fea8bf94b4740b5f304e937d3547..7c9ce56fee998de321c44bb1b0ee9348a33466cc 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java
@@ -104,6 +104,7 @@ public abstract class PostfachNachrichtMapper {
return (attachments instanceof String attachment && StringUtils.isNotBlank(attachment)) || attachments instanceof Collection;
}
+ @SuppressWarnings("unchecked")
private Iterable<String> getAttachments(Object attachments) {
if (attachments instanceof String attachment) {
return Collections.singletonList(attachment);
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java
index bf5ef519eff7a69d61e9b443a1a6dbb67f049992..90d28db00fc2502aa4397ce64077e7769edbcd33 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java
@@ -128,7 +128,6 @@ class PostfachService {
private void persistReceivedMail(PostfachNachricht nachricht) {
persistMail(Optional.empty(), nachricht);
- clientAttributeService.setHasNewPostfachNachricht(nachricht.getVorgangId());
postfachRemoteService.deleteMessage(nachricht.getMessageId());
}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java
index 02d2d73f90b8d8147e58adcb2c19a5117aa37c0f..844c0e77fa1221167695b1c49e89ca594e2b8fa6 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java
@@ -5,6 +5,7 @@ import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.util.Map;
+import java.util.Optional;
import java.util.UUID;
import java.util.stream.Stream;
@@ -21,7 +22,9 @@ import org.mockito.Spy;
import de.ozgcloud.apilib.common.command.OzgCloudCommand;
import de.ozgcloud.apilib.common.command.OzgCloudCommandId;
import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
+import de.ozgcloud.nachrichten.attributes.ClientAttributeService;
import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht.Direction;
import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
class PersistPostfachNachrichtServiceImplTest {
@@ -37,6 +40,221 @@ class PersistPostfachNachrichtServiceImplTest {
private AttachedItemRemoteService attachedItemRemoteService;
@Mock
private PostfachNachrichtMapper postfachNachrichtMapper;
+ @Mock
+ private ClientAttributeService clientAttributeService;
+
+ @DisplayName("Persist nachricht")
+ @Nested
+ class TestPersistNachricht {
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+
+ private final OzgCloudCommand command = OzgCloudCommand.builder().build();
+
+ @BeforeEach
+ void mock() {
+ doReturn(command).when(service).buildNachrichtCommand(any(), any());
+ }
+
+ @Test
+ void shouldBuildNachrichtCommand() {
+ persistNachricht();
+
+ verify(service).buildNachrichtCommand(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldCallCommandService() {
+ persistNachricht();
+
+ verify(commandService).create(command);
+ }
+
+ @Test
+ void shouldSetHasNewPostfachNachricht() {
+ persistNachricht();
+
+ verify(service).setHasNewPostfachNachricht(nachricht);
+ }
+
+ private void persistNachricht() {
+ service.persistNachricht(userIdOpt, nachricht);
+ }
+ }
+
+ @DisplayName("Create base command builder")
+ @Nested
+ class TestCreateBaseComandBuilder {
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+
+ @Test
+ void shouldContainVorgangId() {
+ var command = service.createBaseCommandBuilder(userIdOpt, nachricht).build();
+
+ assertThat(command.getVorgangId()).hasToString(MessageTestFactory.VORGANG_ID);
+ }
+
+ @DisplayName("created by")
+ @Nested
+ class TestCreatedBy {
+
+ @Test
+ void shouldBeAddIfIsPresent() {
+ var command = service.createBaseCommandBuilder(userIdOpt, nachricht).build();
+
+ assertThat(command.getCreatedBy()).hasToString(userId);
+ }
+
+ @Test
+ void shouldNotBeAddIfMissing() {
+ var command = service.createBaseCommandBuilder(Optional.empty(), nachricht).build();
+
+ assertThat(command.getCreatedBy()).isNull();
+ }
+ }
+ }
+
+ @DisplayName("Build nachricht command")
+ @Nested
+ class TestBuildNachrichtCommand {
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final OzgCloudCommand command = OzgCloudCommand.builder().build();
+
+ @DisplayName("on present id")
+ @Nested
+ class TestOnPresentId {
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ doReturn(command).when(service).buildUpdateCommand(any(), any());
+ }
+
+ @Test
+ void shouldBuildUpdateCommand() {
+ service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ verify(service).buildUpdateCommand(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var nachrichtCommand = service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ assertThat(nachrichtCommand).isEqualTo(command);
+ }
+ }
+
+ @DisplayName("on missing id")
+ @Nested
+ class TestOnMissingId {
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+
+ @BeforeEach
+ void mock() {
+ doReturn(command).when(service).buildCreateCommand(any(), any());
+ }
+
+ @Test
+ void shouldBuildCreateCommand() {
+ service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ verify(service).buildCreateCommand(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var nachrichtCommand = service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ assertThat(nachrichtCommand).isEqualTo(command);
+ }
+ }
+
+ @DisplayName("for update")
+ @Nested
+ class TestBuildUpdateCommand {
+
+ private final OzgCloudCommand.OzgCloudCommandBuilder commandBuilder = OzgCloudCommand.builder();
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ doReturn(commandBuilder).when(service).createBaseCommandBuilder(any(), any());
+ }
+
+ @Test
+ void shouldCallCreateBaseCommandBuilder() {
+ buildUpdateCommand();
+
+ verify(service).createBaseCommandBuilder(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldContainOrder() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getOrder()).isEqualTo(PersistPostfachNachrichtServiceImpl.UPDATE_ATTACHED_ITEM_ORDER);
+ }
+
+ @Test
+ void shouldContainRelationId() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getRelationId()).hasToString(PostfachNachrichtTestFactory.ID);
+ }
+
+ @DisplayName("bodyObject")
+ @Nested
+ class TestBodyObject {
+
+ private final Map<String, Object> itemMap = Map.of("dummyKey", "dummyValue");
+
+ @BeforeEach
+ void mock() {
+ when(postfachNachrichtMapper.mapToMap(any())).thenReturn(itemMap);
+ }
+
+ @Test
+ void shouldContainClient() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getBodyObject()).containsEntry(PersistPostfachNachrichtServiceImpl.CLIENT_FIELD,
+ PersistPostfachNachrichtServiceImpl.CLIENT);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ buildUpdateCommand();
+
+ verify(postfachNachrichtMapper).mapToMap(nachricht);
+ }
+
+ @Test
+ void shouldContainItem() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getBodyObject()).containsEntry(PersistPostfachNachrichtServiceImpl.ITEM_FIELD, itemMap);
+ }
+ }
+
+ private OzgCloudCommand buildUpdateCommand() {
+ return service.buildUpdateCommand(userIdOpt, nachricht);
+ }
+ }
+ }
@DisplayName("Persist answer")
@Nested
@@ -46,83 +264,98 @@ class PersistPostfachNachrichtServiceImplTest {
private ArgumentCaptor<PostfachNachricht> postfachNachrichtCaptor;
private final OzgCloudCommand command = OzgCloudCommand.builder().id(OzgCloudCommandId.from(UUID.randomUUID().toString())).build();
- private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.createBuilder().referencedNachricht(null).build();
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().referencedNachricht(null).build();
@BeforeEach
void mock() {
- doReturn(command).when(service).buildCommand(any());
+ doReturn(command).when(service).buildCreateCommand(any(), any());
when(commandService.create(any())).thenReturn(command);
}
@Test
void shouldCallBuildCommand() {
- service.persistAnswer(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID, postfachNachricht);
+ persistAnswer();
- verify(service).buildCommand(postfachNachrichtCaptor.capture());
+ verify(service).buildCreateCommand(eq(Optional.of(PostfachNachrichtTestFactory.CREATED_BY)), postfachNachrichtCaptor.capture());
assertThat(postfachNachrichtCaptor.getValue().getReferencedNachricht()).isEqualTo(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID);
}
@Test
void shouldCallCommandService() {
- service.persistAnswer(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID, postfachNachricht);
+ persistAnswer();
verify(commandService).create(command);
}
+
+ @Test
+ void shouldSetHasNewPostfachNachricht() {
+ persistAnswer();
+
+ verify(service).setHasNewPostfachNachricht(nachricht);
+ }
+
+ void persistAnswer() {
+ service.persistAnswer(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID, nachricht);
+ }
}
- @DisplayName("Build command")
+ @DisplayName("Build create command")
@Nested
- class TestBuildCommand {
+ class TestBuildCreateCommand {
- private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
+ private final OzgCloudCommand.OzgCloudCommandBuilder commandBuilder = OzgCloudCommand.builder();
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+ private final Map<String, Object> itemMap = Map.of("dummyKey", "dummyValue");
@BeforeEach
void mock() {
- doReturn(Map.of("dummyKey", "dummyValue")).when(service).buildCommandBody(any());
+ doReturn(itemMap).when(service).buildCreateItem(any());
+ doReturn(commandBuilder).when(service).createBaseCommandBuilder(any(), any());
}
@Test
- void shouldHaveSetOrder() {
- var command = service.buildCommand(postfachNachricht);
+ void shouldCallCreateBaseCommandBuilder() {
+ buildCreateCommand();
- assertThat(command.getOrder()).isEqualTo(PersistPostfachNachrichtServiceImpl.CREATE_ATTACHED_ITEM_ORDER);
+ verify(service).createBaseCommandBuilder(userIdOpt, nachricht);
}
@Test
- void shouldHaveSetVorgangId() {
- var command = service.buildCommand(postfachNachricht);
+ void shouldContainOrder() {
+ var command = buildCreateCommand();
- assertThat(command.getVorgangId()).hasToString(MessageTestFactory.VORGANG_ID);
+ assertThat(command.getOrder()).isEqualTo(PersistPostfachNachrichtServiceImpl.CREATE_ATTACHED_ITEM_ORDER);
}
@Test
- void shouldHaveSetRelationId() {
- var command = service.buildCommand(postfachNachricht);
+ void shouldContainRelationId() {
+ var command = buildCreateCommand();
assertThat(command.getRelationId()).hasToString(MessageTestFactory.VORGANG_ID);
}
@Test
- void shouldCallBuildCommandBody() {
- service.buildCommand(postfachNachricht);
+ void shouldContainBodyObject() {
+ var command = buildCreateCommand();
- verify(service).buildCommandBody(postfachNachricht);
+ assertThat(command.getBodyObject()).isEqualTo(itemMap);
}
- @Test
- void shouldHaveSetBodyObjet() {
- var command = service.buildCommand(postfachNachricht);
-
- assertThat(command.getBodyObject()).isNotEmpty();
+ private OzgCloudCommand buildCreateCommand() {
+ return service.buildCreateCommand(userIdOpt, nachricht);
}
}
- @DisplayName("Build command body")
+ @DisplayName("Build create item")
@Nested
class TestBuildCommandBody {
private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
- private Map<String, Object> postfachNachrichtAsMap = Map.of("dummyKey", "dummyValue");
+ private final Map<String, Object> postfachNachrichtAsMap = Map.of("dummyKey", "dummyValue");
@BeforeEach
void mock() {
@@ -131,40 +364,63 @@ class PersistPostfachNachrichtServiceImplTest {
@Test
void shouldHaveSetClient() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.CLIENT_FIELD, PersistPostfachNachrichtServiceImpl.CLIENT);
}
@Test
void shouldHaveSetVorgangId() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.VORGANG_ID_FIELD, MessageTestFactory.VORGANG_ID);
}
@Test
void shouldHaveSetItemName() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.ITEM_NAME_FIELD, PersistPostfachNachrichtServiceImpl.ITEM_NAME);
}
@Test
void shouldCallMapper() {
- service.buildCommandBody(postfachNachricht);
+ service.buildCreateItem(postfachNachricht);
verify(postfachNachrichtMapper).mapToMap(postfachNachricht);
}
@Test
void shouldHaveSetItem() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.ITEM_FIELD, postfachNachrichtAsMap);
}
}
+ @DisplayName("Set has new postfach nachricht")
+ @Nested
+ class TestSetHasNewPostfachNachricht {
+
+ @Test
+ void shouldCallClientAttributeServiceIfIsIncomingNachricht() {
+ var incomingNachricht = PostfachNachrichtTestFactory.createBuilder().direction(Direction.IN).build();
+
+ service.setHasNewPostfachNachricht(incomingNachricht);
+
+ verify(clientAttributeService).setHasNewPostfachNachricht(MessageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldNOTCallClientAttributeServiceIfIsOutgoindNachricht() {
+ var outgoingNachricht = PostfachNachrichtTestFactory.createBuilder().direction(Direction.OUT).build();
+
+ service.setHasNewPostfachNachricht(outgoingNachricht);
+
+ verify(clientAttributeService, never()).setHasNewPostfachNachricht(any());
+ }
+ }
+
@DisplayName("Find answers")
@Nested
class TestFindAnswers {
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java
index 495a14faa0c0a0889dae79daf0d11a6703860748..ac8d6773fd1e363c8d9552a3307ea4a11c3c613d 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java
@@ -399,20 +399,6 @@ class PostfachServiceTest {
verify(postfachRemoteService).deleteMessage(MessageTestFactory.MESSAGE_ID);
}
- @Test
- void shouldSetNewPostfachNachricht() {
- service.fetchAndPersistReplies();
-
- verify(clientAttributeService).setHasNewPostfachNachricht(MessageTestFactory.VORGANG_ID);
- }
-
- @Test
- void shouldCallClientAttributeService() {
- service.fetchAndPersistReplies();
-
- verify(clientAttributeService).setHasNewPostfachNachricht(MessageTestFactory.VORGANG_ID);
- }
-
@Test
void shouldThrowNotConfiguredException() {
doReturn(false).when(service).isPostfachConfigured();