+
+ @Test
+ @DisplayName("Assert, that ChatMessageService.persistMessage() is not called, if a message is added again with mutated text")
+ void testAddMutatedDoesNotTriggerPersistence()
+ {
+ // Given
+ String messageText = "Bar";
+ String mutatedText = "Boom!";
+ Message existingMessage = new Message(key, 0l, timestamp, messageText);
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.just(existingMessage));
+
+ // When
+ chatRoomData
+ .addMessage(messageId, user, mutatedText)
+ .onErrorResume((throwable) -> Mono.empty())
+ .block();
+
+ // Then
+ verify(chatMessageService, never()).persistMessage(any(), any(), any());
+ }
+
+ @Test
+ @DisplayName("Assert, that Mono sends an error, if a message is sent to a closed chat-room")
+ void testAddMessageToClosedChatRoomSendsError()
+ {
+ // Given
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(someMessage()));
+
+ chatRoomData.deactivate();
+
+ // When
+ Mono<Message> mono = chatRoomData.addMessage(messageId, user, "Some text");
+
+ // Then
+ assertThat(mono).sendsError();
+ }
+
+ @Test
+ @DisplayName("Assert, that ChatMessageService.persistMessage() is not called if a message is sent to a closed chat-room")
+ void testAddMessageToClosedChatRoomDoesNotTriggerPersistence()
+ {
+ // Given
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(someMessage()));
+
+ chatRoomData.deactivate();
+
+ // When
+ chatRoomData
+ .addMessage(messageId, user, "Some text")
+ .onErrorResume((throwable) -> Mono.empty())
+ .block();
+
+ // Then
+ verify(chatMessageService, never()).persistMessage(any(), any(), any());
+ }
+
+ @Test
+ @DisplayName("Assert, that a listener receives a message, that was added after the listening had started")
+ void testListenerReceivesMessageAddedAfterListeningStarts()
+ {
+ // Given
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(someMessage()));
+
+ // When
+ List<Message> receivedMessages = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> receivedMessages.add(receivedMessage));
+ Message sentMessage = chatRoomData
+ .addMessage(messageId, user, "Some Text")
+ .block();
+
+ // Then
+ Awaitility
+ .await()
+ .atMost(Duration.ofSeconds(1))
+ .untilAsserted(() -> assertThat(receivedMessages).contains(sentMessage));
+ }
+
+ @Test
+ @DisplayName("Assert, that a listener receives a message, that was added before the listening had started")
+ void testListenerReceivesMessageAddedBeforeListeningStarts()
+ {
+ // Given
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(someMessage()));
+
+ // When
+ Message sentMessage = chatRoomData
+ .addMessage(messageId, user, "Some Text")
+ .block();
+ List<Message> receivedMessages = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> receivedMessages.add(receivedMessage));
+
+ // Then
+ Awaitility
+ .await()
+ .atMost(Duration.ofSeconds(1))
+ .untilAsserted(() -> assertThat(receivedMessages).contains(sentMessage));
+ }
+
+ @Test
+ @DisplayName("Assert, that a listener receives several messages, that were added before and after the listening had started, in correct order")
+ void testListenerReceivesMessagesFromBeforeAndAfterListeningHadStartedInCorrectOrder()
+ {
+ // Given
+ Message message1 = new Message(key, 1l, timestamp, "#1");
+ Message message2 = new Message(key, 2l, timestamp, "#2");
+ Message message3 = new Message(key, 3l, timestamp, "#3");
+ Message message4 = new Message(key, 4l, timestamp, "#4");
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(message1))
+ .thenReturn(Mono.just(message2))
+ .thenReturn(Mono.just(message3))
+ .thenReturn(Mono.just(message4));
+
+ // When
+ Message[] sentMessages = new Message[4];
+ sentMessages[0] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ sentMessages[1] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ List<Message> receivedMessages = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> receivedMessages.add(receivedMessage));
+ sentMessages[2] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ sentMessages[3] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+
+ // Then
+ Awaitility
+ .await()
+ .atMost(Duration.ofSeconds(1))
+ .untilAsserted(() -> assertThat(receivedMessages).contains(sentMessages));
+ }
+
+ @Test
+ @DisplayName("Assert, that multiple listeners can receive an added message")
+ void testMultipleListeners()
+ {
+ // Given
+ Message message1 = new Message(key, 1l, timestamp, "#1");
+ Message message2 = new Message(key, 2l, timestamp, "#2");
+ Message message3 = new Message(key, 3l, timestamp, "#3");
+ Message message4 = new Message(key, 4l, timestamp, "#4");
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(message1))
+ .thenReturn(Mono.just(message2))
+ .thenReturn(Mono.just(message3))
+ .thenReturn(Mono.just(message4));
+
+ // When
+ Message[] sentMessages = new Message[4];
+ List<Message> messagesReceivedByListener1 = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> messagesReceivedByListener1.add(receivedMessage));
+ sentMessages[0] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ sentMessages[1] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ List<Message> messagesReceivedByListener2 = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> messagesReceivedByListener2.add(receivedMessage));
+ sentMessages[2] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ List<Message> messagesReceivedByListener3 = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> messagesReceivedByListener3.add(receivedMessage));
+ sentMessages[3] = chatRoomData.addMessage(messageId, user, "Some Text").block();
+ List<Message> messagesReceivedByListener4 = new LinkedList<>();
+ chatRoomData
+ .listen()
+ .subscribe(receivedMessage -> messagesReceivedByListener4.add(receivedMessage));
+
+ // Then
+ Awaitility
+ .await()
+ .atMost(Duration.ofSeconds(1))
+ .untilAsserted(() ->
+ {
+ assertThat(messagesReceivedByListener1).contains(sentMessages);
+ assertThat(messagesReceivedByListener2).contains(sentMessages);
+ assertThat(messagesReceivedByListener3).contains(sentMessages);
+ assertThat(messagesReceivedByListener4).contains(sentMessages);
+ });
+ }
+
+ @Test
+ @DisplayName("Assert, that a listended to chat-room emits completed, if it is closed")
+ void testListenedToChatRoomEmitsCompletedIfItIsClosed()
+ {
+ // Given
+ Message message1 = new Message(key, 1l, timestamp, "#1");
+ Message message2 = new Message(key, 2l, timestamp, "#2");
+ Message message3 = new Message(key, 3l, timestamp, "#3");
+ Message message4 = new Message(key, 4l, timestamp, "#4");
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
+ .thenReturn(Mono.empty());
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ .thenReturn(Mono.just(message1))
+ .thenReturn(Mono.just(message2))
+ .thenReturn(Mono.just(message3))
+ .thenReturn(Mono.just(message4));
+
+ chatRoomData.addMessage(messageId, user, "Some Text").block();
+ chatRoomData.addMessage(messageId, user, "Some Text").block();
+ chatRoomData.addMessage(messageId, user, "Some Text").block();
+ chatRoomData.addMessage(messageId, user, "Some Text").block();
+
+ // When
+ Flux<Message> listenFlux = chatRoomData.listen();
+ chatRoomData.deactivate();
+
+ // Then
+ assertThat(listenFlux).emitsExactly(
+ message1,
+ message2,
+ message3,
+ message4);
+ }
+
+ @Test
+ @DisplayName("Assert, that a listended to chat-room emits completed, if it is closed")
+ void testListeningToClosedChatRoomSendsError()
+ {
+ // Given
+ chatRoomData.deactivate();
+
+ // When
+ Flux<Message> listenFlux = chatRoomData.listen();
+
+ // Then
+ assertThat(listenFlux).sendsError();
+ }
+
+
+ /**
+ * This message is used, when methods of {@link ChatMessageService} are mocked,
+ * that return a {@link Message}.
+ * The contents of the message are set to arbitrary values, in order to underline
+ * the fact, that the test can only assert, that the message that was returned
+ * by {@link ChatMessageService} is handed on by {@link ChatRoomData} correctly.
+ * @return a message.
+ */
+ private Message someMessage()
+ {
+ return new Message(
+ Message.MessageKey.of("FOO", 666l),
+ 666l,
+ LocalDateTime.of(2024, 3, 8, 12, 13, 00),
+ "Just some message...");
+ }