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
 120     // When
 121     Mono<Message> mono = chatRoomData.addMessage(messageId, user, messageText);
 122
 123     // Then
 124     assertThat(mono).emitsExactly(message);
 125   }
 126
 127   @Test
 128   @DisplayName("Assert, that ChatMessageService.persistMessage() is not called, if an unchanged message is added")
 129   void testAddUnchangedMessageDoesNotTriggerPersistence()
 130   {
 131     // Given
 132     String messageText = "Bar";
 133     Message message = new Message(key, 0l, timestamp, messageText);
 134     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 135
 136     // When
 137     chatRoomData
 138         .addMessage(messageId, user, messageText)
 139         .block();
 140
 141     // Then
 142     verify(chatMessageService, never()).persistMessage(any(), any(), any());
 143   }
 144
 145   @Test
 146   @DisplayName("Assert, that Mono sends an error, if a message is added again with mutated text")
 147   void testAddMutatedMessageSendsError()
 148   {
 149     // Given
 150     String messageText = "Bar";
 151     String mutatedText = "Boom!";
 152     Message message = new Message(key, 0l, timestamp, messageText);
 153     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 154
 155     // When
 156     Mono<Message> mono = chatRoomData.addMessage(messageId, user, mutatedText);
 157
 158     // Then
 159     assertThat(mono).sendsError();
 160   }
 161
 162   @Test
 163   @DisplayName("Assert, that ChatMessageService.persistMessage() is not called, if a message is added again with mutated text")
 164   void testAddMutatedDoesNotTriggerPersistence()
 165   {
 166     // Given
 167     String messageText = "Bar";
 168     String mutatedText = "Boom!";
 169     Message message = new Message(key, 0l, timestamp, messageText);
 170     when(chatMessageService.getMessage(any(Message.MessageKey.class))).thenReturn(Mono.just(message));
 171
 172     // When
 173     chatRoomData
 174         .addMessage(messageId, user, mutatedText)
 175         .onErrorResume((throwable) -> Mono.empty())
 176         .block();
 177
 178     // Then
 179     verify(chatMessageService, never()).persistMessage(any(), any(), any());
 180   }
 181 }