import de.juplo.kafka.chat.backend.ChatBackendProperties;
import de.juplo.kafka.chat.backend.domain.*;
-import de.juplo.kafka.chat.backend.persistence.inmemory.InMemoryChatHomeService;
-import de.juplo.kafka.chat.backend.persistence.inmemory.ShardingStrategy;
+import de.juplo.kafka.chat.backend.domain.exceptions.ShardNotOwnedException;
+import de.juplo.kafka.chat.backend.domain.exceptions.UnknownChatroomException;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.time.Clock;
import java.time.LocalDateTime;
-import java.util.Set;
import java.util.UUID;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@SpringBootTest(properties = {
"spring.main.allow-bean-definition-overriding=true",
- "chat.backend.inmemory.sharding-strategy=kafkalike",
- "chat.backend.inmemory.num-shards=10",
- "chat.backend.inmemory.owned-shards=6",
})
@AutoConfigureWebTestClient
@Slf4j
{
@Autowired
ChatBackendProperties properties;
- @Autowired
- ShardingStrategy shardingStrategy;
@MockBean
- InMemoryChatHomeService chatHomeService;
+ ChatHomeService chatHomeService;
@MockBean
- ChatRoomService chatRoomService;
+ ChatMessageService chatMessageService;
@Test
@DisplayName("Assert expected problem-details for unknown chatroom on GET /list/{chatroomId}")
void testUnknownChatroomExceptionForListChatroom(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
- when(chatHomeService.getOwnedShards()).thenReturn(new int[] { 6 });
+ UUID chatroomId = UUID.randomUUID();
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new UnknownChatroomException(chatroomId));
// When
WebTestClient.ResponseSpec responseSpec = client
void testUnknownChatroomExceptionForGetChatroom(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
- when(chatHomeService.getOwnedShards()).thenReturn(new int[] { 6 });
+ UUID chatroomId = UUID.randomUUID();
+ when(chatHomeService.getChatRoomInfo(eq(chatroomId))).thenThrow(new UnknownChatroomException(chatroomId));
// When
WebTestClient.ResponseSpec responseSpec = client
void testUnknownChatroomExceptionForPutMessage(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
+ UUID chatroomId = UUID.randomUUID();
String username = "foo";
Long messageId = 66l;
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
- when(chatHomeService.getOwnedShards()).thenReturn(new int[] { 6 });
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new UnknownChatroomException(chatroomId));
// When
WebTestClient.ResponseSpec responseSpec = client
void testUnknownChatroomExceptionForGetMessage(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
+ UUID chatroomId = UUID.randomUUID();
String username = "foo";
Long messageId = 66l;
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
- when(chatHomeService.getOwnedShards()).thenReturn(new int[] { 6 });
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new UnknownChatroomException(chatroomId));
// When
WebTestClient.ResponseSpec responseSpec = client
void testUnknownChatroomExceptionForListenChatroom(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
- when(chatHomeService.getOwnedShards()).thenReturn(new int[] { 6 });
+ UUID chatroomId = UUID.randomUUID();
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new UnknownChatroomException(chatroomId));
// When
WebTestClient.ResponseSpec responseSpec = client
void testMessageMutationException(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
+ UUID chatroomId = UUID.randomUUID();
String user = "foo";
Long messageId = 66l;
Message.MessageKey key = Message.MessageKey.of(user, messageId);
LocalDateTime timeExistingMessage = LocalDateTime.parse(timeExistingMessageAsString);
String textExistingMessage = "Existing";
String textMutatedMessage = "Mutated!";
- ChatRoom chatRoom = new ChatRoom(
- chatroomId,
- "Test-ChatRoom",
- 0,
+ ChatRoomData chatRoomData = new ChatRoomData(
Clock.systemDefaultZone(),
- chatRoomService, 8);
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.just(chatRoom));
+ chatMessageService,
+ 8);
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenReturn(Mono.just(chatRoomData));
Message existingMessage = new Message(
key,
serialNumberExistingMessage,
timeExistingMessage,
textExistingMessage);
- when(chatRoomService.getMessage(any(Message.MessageKey.class)))
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
.thenReturn(Mono.just(existingMessage));
// Needed for readable error-reports, in case of a bug that leads to according unwanted call
- when(chatRoomService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
.thenReturn(Mono.just(mock(Message.class)));
// When
.jsonPath("$.existingMessage.user").isEqualTo(user)
.jsonPath("$.existingMessage.text").isEqualTo(textExistingMessage)
.jsonPath("$.mutatedText").isEqualTo(textMutatedMessage);
- verify(chatRoomService, never()).persistMessage(eq(key), any(LocalDateTime.class), any(String.class));
+ verify(chatMessageService, never()).persistMessage(eq(key), any(LocalDateTime.class), any(String.class));
}
@Test
void testInvalidUsernameException(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForOwnedShard();
+ UUID chatroomId = UUID.randomUUID();
String user = "Foo";
Long messageId = 66l;
Message.MessageKey key = Message.MessageKey.of(user, messageId);
String textMessage = "Hallo Welt";
- ChatRoom chatRoom = new ChatRoom(
- chatroomId,
- "Test-ChatRoom",
- 0,
+ ChatRoomData chatRoomData = new ChatRoomData(
Clock.systemDefaultZone(),
- chatRoomService, 8);
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class)))
- .thenReturn(Mono.just(chatRoom));
- when(chatRoomService.getMessage(any(Message.MessageKey.class)))
+ chatMessageService,
+ 8);
+ when(chatHomeService.getChatRoomData(any(UUID.class)))
+ .thenReturn(Mono.just(chatRoomData));
+ when(chatMessageService.getMessage(any(Message.MessageKey.class)))
.thenReturn(Mono.empty());
// Needed for readable error-reports, in case of a bug that leads to according unwanted call
- when(chatRoomService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
+ when(chatMessageService.persistMessage(any(Message.MessageKey.class), any(LocalDateTime.class), any(String.class)))
.thenReturn(Mono.just(mock(Message.class)));
// When
.expectBody()
.jsonPath("$.type").isEqualTo("/problem/invalid-username")
.jsonPath("$.username").isEqualTo(user);
- verify(chatRoomService, never()).persistMessage(eq(key), any(LocalDateTime.class), any(String.class));
+ verify(chatMessageService, never()).persistMessage(eq(key), any(LocalDateTime.class), any(String.class));
}
@Test
void testShardNotOwnedExceptionForGetChatroom(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForForeignShard();
+ UUID chatroomId = UUID.randomUUID();
+ String instanceId = "peter";
+ int shard = 666;
+ when(chatHomeService.getChatRoomInfo(eq(chatroomId))).thenThrow(new ShardNotOwnedException(instanceId, shard));
// When
WebTestClient.ResponseSpec responseSpec = client
.exchange();
// Then
- assertProblemDetailsForShardNotOwnedException(responseSpec, shardingStrategy.selectShard(chatroomId));
+ assertProblemDetailsForShardNotOwnedException(responseSpec, shard);
}
@Test
void testShardNotOwnedExceptionForListChatroom(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForForeignShard();
+ UUID chatroomId = UUID.randomUUID();
+ String instanceId = "peter";
+ int shard = 666;
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new ShardNotOwnedException(instanceId, shard));
// When
WebTestClient.ResponseSpec responseSpec = client
.exchange();
// Then
- assertProblemDetailsForShardNotOwnedException(responseSpec, shardingStrategy.selectShard(chatroomId));
+ assertProblemDetailsForShardNotOwnedException(responseSpec, shard);
}
@Test
- @DisplayName("Assert expected problem-details for now owned shard on PUT /put/{chatroomId}/{username}/{messageId}")
+ @DisplayName("Assert expected problem-details for not owned shard on PUT /put/{chatroomId}/{username}/{messageId}")
void testShardNotOwnedExceptionForPutMessage(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForForeignShard();
+ UUID chatroomId = UUID.randomUUID();
String username = "foo";
Long messageId = 66l;
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
+ String instanceId = "peter";
+ int shard = 666;
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new ShardNotOwnedException(instanceId, shard));
// When
WebTestClient.ResponseSpec responseSpec = client
.exchange();
// Then
- assertProblemDetailsForShardNotOwnedException(responseSpec, shardingStrategy.selectShard(chatroomId));
+ assertProblemDetailsForShardNotOwnedException(responseSpec, shard);
}
@Test
void testShardNotOwnedExceptionForGetMessage(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForForeignShard();
+ UUID chatroomId = UUID.randomUUID();
String username = "foo";
Long messageId = 66l;
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
+ String instanceId = "peter";
+ int shard = 666;
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new ShardNotOwnedException(instanceId, shard));
// When
WebTestClient.ResponseSpec responseSpec = client
.exchange();
// Then
- assertProblemDetailsForShardNotOwnedException(responseSpec, shardingStrategy.selectShard(chatroomId));
+ assertProblemDetailsForShardNotOwnedException(responseSpec, shard);
}
@Test
void testShardNotOwnedExceptionForListenChatroom(@Autowired WebTestClient client)
{
// Given
- UUID chatroomId = getRandomIdForForeignShard();
- when(chatHomeService.getChatRoom(anyInt(), any(UUID.class))).thenReturn(Mono.empty());
+ UUID chatroomId = UUID.randomUUID();
+ String instanceId = "peter";
+ int shard = 666;
+ when(chatHomeService.getChatRoomData(eq(chatroomId))).thenThrow(new ShardNotOwnedException(instanceId, shard));
// When
WebTestClient.ResponseSpec responseSpec = client
.exchange();
// Then
- assertProblemDetailsForShardNotOwnedException(responseSpec, shardingStrategy.selectShard(chatroomId));
+ assertProblemDetailsForShardNotOwnedException(responseSpec, shard);
}
private void assertProblemDetailsForShardNotOwnedException(
.jsonPath("$.type").isEqualTo("/problem/shard-not-owned")
.jsonPath("$.shard").isEqualTo(shard);
}
-
- private UUID getRandomIdForOwnedShard()
- {
- Set<Integer> ownedShards = ownedShards();
- UUID randomId;
-
- do
- {
- randomId = UUID.randomUUID();
- }
- while (!ownedShards.contains(shardingStrategy.selectShard(randomId)));
-
- return randomId;
- }
-
- private UUID getRandomIdForForeignShard()
- {
- Set<Integer> ownedShards = ownedShards();
- UUID randomId;
-
- do
- {
- randomId = UUID.randomUUID();
- }
- while (ownedShards.contains(shardingStrategy.selectShard(randomId)));
-
- return randomId;
- }
-
- private Set<Integer> ownedShards()
- {
- return IntStream
- .of(properties.getInmemory().getOwnedShards())
- .mapToObj(shard -> Integer.valueOf(shard))
- .collect(Collectors.toSet());
- }
}