juplo.de Git - demos/kafka/chat/blob - src/test/java/de/juplo/kafka/chat/backend/domain/ChatRoomDataTest.java

   1 package de.juplo.kafka.chat.backend.domain;
   2
   3 import org.junit.jupiter.api.BeforeEach;
   4 import org.junit.jupiter.api.DisplayName;
   5 import org.junit.jupiter.api.Test;
   6 import reactor.core.publisher.Mono;
   7
   8 import java.time.Clock;
   9 import java.time.Instant;
  10 import java.time.LocalDateTime;
  11 import java.time.ZoneId;
  12
  13 import static org.mockito.Mockito.*;
  14 import static pl.rzrz.assertj.reactor.Assertions.assertThat;
  15
  16
  17 public class ChatRoomDataTest
  18 {
  19   Clock now;
  20   ChatMessageService chatMessageService;
  21   ChatRoomData chatRoomData;
  22
  23   String user;
  24   Long messageId;
  25   Message.MessageKey key;
  26   LocalDateTime timestamp;
  27
  28
  29   @BeforeEach
  30   public void setUp()
  31   {
  32     now = Clock.fixed(Instant.now(), ZoneId.systemDefault());
  33     chatMessageService = mock(ChatMessageService.class);
  34     chatRoomData = new ChatRoomData(
  35         now,
  36         chatMessageService,
  37         8);
  38
  39     user = "foo";
  40     messageId = 1l;
  41     key = Message.MessageKey.of(user, messageId);
  42     timestamp = LocalDateTime.now(now);
  43   }
  44
  45
  46   @Test
  47   @DisplayName("Assert, that Mono emits expected message, if it exists")
  48   void testGetExistingMessage()
  49   {
  50     // Given
  51     Message message = new Message(key, 0l, timestamp, "Bar");
  52     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
  53
  54     // When
  55     Mono<Message> mono = chatRoomData.getMessage(user, messageId);
  56
  57     // Then
  58     assertThat(mono).emitsExactly(message);
  59   }
  60
  61   @Test
  62   @DisplayName("Assert, that Mono is empty, if message does not exists")
  63   void testGetNonExistentMessage()
  64   {
  65     // Given
  66     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.empty());
  67
  68     // When
  69     Mono<Message> mono = chatRoomData.getMessage(user, messageId);
  70
  71     // Then
  72     assertThat(mono).emitsCount(0);
  73   }
  74
  75   @Test
  76   @DisplayName("Assert, that Mono emits the persisted message, if a new message is added")
  77   void testAddNewMessageEmitsPersistedMessage()
  78   {
  79     // Given
  80     String messageText = "Bar";
  81     Message message = new Message(key, 0l, timestamp, messageText);
  82     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.empty());
  83     when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class))).thenReturn(Mono.just(message));
  84
  85     // When
  86     Mono<Message> mono = chatRoomData.addMessage(messageId, user, messageText);
  87
  88     // Then
  89     assertThat(mono).emitsExactly(message);
  90   }
  91
  92   @Test
  93   @DisplayName("Assert, that ChatMessageService.persistMessage() is called correctly, if a new message is added")
  94   void testAddNewMessageTriggersPersistence()
  95   {
  96     // Given
  97     String messageText = "Bar";
  98     Message message = new Message(key, 0l, timestamp, messageText);
  99     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.empty());
 100     when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class))).thenReturn(Mono.just(message));
 101
 102     // When
 103     chatRoomData
 104         .addMessage(messageId, user, messageText)
 105         .block();
 106
 107     // Then
 108     verify(chatMessageService, times(1)).persistMessage(eq(key), eq(timestamp), eq(messageText));
 109   }
 110
 111   @Test
 112   @DisplayName("Assert, that Mono emits the already persisted message, if an unchanged message is added")
 113   void testAddUnchangedMessageEmitsAlreadyPersistedMessage()
 114   {
 115     // Given
 116     String messageText = "Bar";
 117     Message message = new Message(key, 0l, timestamp, messageText);
 118     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 119     when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class))).thenReturn(Mono.just(message));
 120
 121     // When
 122     Mono<Message> mono = chatRoomData.addMessage(messageId, user, messageText);
 123
 124     // Then
 125     assertThat(mono).emitsExactly(message);
 126   }
 127
 128   @Test
 129   @DisplayName("Assert, that ChatMessageService.persistMessage() is not called, if an unchanged message is added")
 130   void testAddUnchangedMessageDoesNotTriggerPersistence()
 131   {
 132     // Given
 133     String messageText = "Bar";
 134     Message message = new Message(key, 0l, timestamp, messageText);
 135     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 136     when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class))).thenReturn(Mono.just(message));
 137
 138     // When
 139     chatRoomData
 140         .addMessage(messageId, user, messageText)
 141         .block();
 142
 143     // Then
 144     verify(chatMessageService, never()).persistMessage(any(), any(), any());
 145   }
 146
 147   @Test
 148   @DisplayName("Assert, that Mono sends an error, if a message is added again with mutated text")
 149   void testAddMutatedMessageSendsError()
 150   {
 151     // Given
 152     String messageText = "Bar";
 153     String mutatedText = "Boom!";
 154     Message message = new Message(key, 0l, timestamp, messageText);
 155     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 156     when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class))).thenReturn(Mono.just(message));
 157
 158     // When
 159     Mono<Message> mono = chatRoomData.addMessage(messageId, user, mutatedText);
 160
 161     // Then
 162     assertThat(mono).sendsError();
 163   }
 164
 165   @Test
 166   @DisplayName("Assert, that ChatMessageService.persistMessage() is not called, if a message is added again with mutated text")
 167   void testAddMutatedDoesNotTriggerPersistence()
 168   {
 169     // Given
 170     String messageText = "Bar";
 171     String mutatedText = "Boom!";
 172     Message message = new Message(key, 0l, timestamp, messageText);
 173     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 174     when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class))).thenReturn(Mono.just(message));
 175
 176     // When
 177     chatRoomData
 178         .addMessage(messageId, user, mutatedText)
 179         .onErrorResume((throwable) -> Mono.empty())
 180         .block();
 181
 182     // Then
 183     verify(chatMessageService, never()).persistMessage(any(), any(), any());
 184   }
 185 }