Dragonestia/RoomPicker
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed tests

Browse Source
This commit is contained in:
Andrey Terentev 2024-03-13 17:05:37 +07:00 committed by Andrey Terentev
parent c13f566099
commit 65c78df852
8 changed files with 57 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client-api/src/test/java/util/IdentifierValidatorTests.java
View File

@ -34,8 +34,8 @@ public class IdentifierValidatorTests {
Assertions.assertFalse(IdentifierValidator.forRoom("-")); Assertions.assertFalse(IdentifierValidator.forRoom("-"));
Assertions.assertFalse(IdentifierValidator.forRoom("-a")); Assertions.assertFalse(IdentifierValidator.forRoom("-a"));
Assertions.assertFalse(IdentifierValidator.forRoom("a-")); Assertions.assertFalse(IdentifierValidator.forRoom("a-"));
Assertions.assertTrue(IdentifierValidator.forRoom("a".repeat(32))); Assertions.assertTrue(IdentifierValidator.forRoom("a".repeat(36)));
Assertions.assertFalse(IdentifierValidator.forRoom("a".repeat(33))); Assertions.assertFalse(IdentifierValidator.forRoom("a".repeat(37)));
} }
@Test @Test

14
server/src/test/java/ru/dragonestia/picker/config/FillingNodesConfig.java
View File

@ -4,10 +4,12 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.TestConfiguration; import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import ru.dragonestia.picker.api.model.node.PickingMethod; import ru.dragonestia.picker.api.model.node.PickingMethod;
import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
import ru.dragonestia.picker.api.repository.type.RoomIdentifier;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.Node; import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.model.Room; import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User; import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.model.type.SlotLimit;
import ru.dragonestia.picker.repository.NodeRepository; import ru.dragonestia.picker.repository.NodeRepository;
import ru.dragonestia.picker.repository.RoomRepository; import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.UserRepository; import ru.dragonestia.picker.repository.UserRepository;
@ -51,7 +53,7 @@ public class FillingNodesConfig {
@Bean @Bean
void createSequentialFillingNode() { void createSequentialFillingNode() {
var node = new Node("seq", PickingMethod.SEQUENTIAL_FILLING, false); var node = new Node(NodeIdentifier.of("seq"), PickingMethod.SEQUENTIAL_FILLING, false);
nodeRepository.create(node); nodeRepository.create(node);
fillNode(node); fillNode(node);
@ -61,7 +63,7 @@ public class FillingNodesConfig {
@Bean @Bean
void createRoundRobinNode() { void createRoundRobinNode() {
var node = new Node("round", PickingMethod.ROUND_ROBIN, false); var node = new Node(NodeIdentifier.of("round"), PickingMethod.ROUND_ROBIN, false);
nodeRepository.create(node); nodeRepository.create(node);
fillNode(node); fillNode(node);
@ -71,7 +73,7 @@ public class FillingNodesConfig {
@Bean @Bean
void createLeastPickerNode() { void createLeastPickerNode() {
var node = new Node("least", PickingMethod.LEAST_PICKED, false); var node = new Node(NodeIdentifier.of("least"), PickingMethod.LEAST_PICKED, false);
nodeRepository.create(node); nodeRepository.create(node);
fillNode(node); fillNode(node);
@ -83,12 +85,12 @@ public class FillingNodesConfig {
for (int i = 0, n = 5; i < n; i++) { for (int i = 0, n = 5; i < n; i++) {
for (int j = 0; j < 3; j++) { for (int j = 0; j < 3; j++) {
var roomId = "room-" + i + "-" + j; var roomId = "room-" + i + "-" + j;
var room = Room.create(roomId, node, SlotLimit.of(n), "", false); var room = new Room(RoomIdentifier.of(roomId), node, n, "", false);
roomRepository.create(room); roomRepository.create(room);
var users = n - i; var users = n - i;
for (int k = users - 1; k >= 0; k--) { for (int k = users - 1; k >= 0; k--) {
var user = new User("user-" + k); var user = new User(UserIdentifier.of("user-" + k));
userRepository.linkWithRoom(room, List.of(user), false); userRepository.linkWithRoom(room, List.of(user), false);
} }

6
server/src/test/java/ru/dragonestia/picker/picker/LeastPickedTests.java
View File

@ -44,11 +44,11 @@ public class LeastPickedTests {
Assertions.assertTrue(roomOpt.isPresent()); Assertions.assertTrue(roomOpt.isPresent());
var room = roomOpt.get(); var room = roomOpt.get();
var slots = room.getSlots(); var slots = room.getMaxSlots();
var users = userRepository.usersOf(room); var users = userRepository.usersOf(room);
Assertions.assertTrue(slots.isUnlimited() || slots.getSlots() >= users.size()); // check slots limitation Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation
Assertions.assertEquals(expectedRoomId, room.getId()); Assertions.assertEquals(expectedRoomId, room.getIdentifier());
} }
public static class PickingArgumentProvider implements ArgumentsProvider { public static class PickingArgumentProvider implements ArgumentsProvider {

7
server/src/test/java/ru/dragonestia/picker/picker/RoundRobinTests.java
View File

@ -8,6 +8,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import; import org.springframework.context.annotation.Import;
import ru.dragonestia.picker.api.model.node.INode;
import ru.dragonestia.picker.config.FillingNodesConfig; import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.model.Node; import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.repository.RoomRepository; import ru.dragonestia.picker.repository.RoomRepository;
@ -42,11 +43,11 @@ public class RoundRobinTests {
Assertions.assertTrue(roomOpt.isPresent()); Assertions.assertTrue(roomOpt.isPresent());
var room = roomOpt.get(); var room = roomOpt.get();
var slots = room.getSlots(); var slots = room.getMaxSlots();
var users = userRepository.usersOf(room); var users = userRepository.usersOf(room);
Assertions.assertTrue(slots.isUnlimited() || slots.getSlots() >= users.size()); // check slots limitation Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation
Assertions.assertEquals(expectedRoomId, room.getId()); Assertions.assertEquals(expectedRoomId, room.getIdentifier());
} }
public static class PickingArgumentProvider implements ArgumentsProvider { public static class PickingArgumentProvider implements ArgumentsProvider {

6
server/src/test/java/ru/dragonestia/picker/picker/SequentialFillingTests.java
View File

@ -44,11 +44,11 @@ public class SequentialFillingTests {
Assertions.assertTrue(roomOpt.isPresent()); Assertions.assertTrue(roomOpt.isPresent());
var room = roomOpt.get(); var room = roomOpt.get();
var slots = room.getSlots(); var slots = room.getMaxSlots();
var users = userRepository.usersOf(room); var users = userRepository.usersOf(room);
Assertions.assertTrue(slots.isUnlimited() || slots.getSlots() >= users.size()); // check slots limitation Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation
Assertions.assertEquals(expectedRoomId, room.getId()); Assertions.assertEquals(expectedRoomId, room.getIdentifier());
} }
public static class PickingArgumentProvider implements ArgumentsProvider { public static class PickingArgumentProvider implements ArgumentsProvider {

13
server/src/test/java/ru/dragonestia/picker/service/NodeServiceTests.java
View File

@ -6,6 +6,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest;
import ru.dragonestia.picker.api.exception.NodeAlreadyExistException; import ru.dragonestia.picker.api.exception.NodeAlreadyExistException;
import ru.dragonestia.picker.api.model.node.PickingMethod; import ru.dragonestia.picker.api.model.node.PickingMethod;
import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
import ru.dragonestia.picker.model.Node; import ru.dragonestia.picker.model.Node;
import java.util.List; import java.util.List;
@ -18,15 +19,15 @@ public class NodeServiceTests {
@Test @Test
void test_nodeCreateAndRemove() { void test_nodeCreateAndRemove() {
var node = new Node("test", PickingMethod.SEQUENTIAL_FILLING, false); var node = new Node(NodeIdentifier.of("test"), PickingMethod.SEQUENTIAL_FILLING, false);
Assertions.assertDoesNotThrow(() -> nodeService.create(node)); Assertions.assertDoesNotThrow(() -> nodeService.create(node));
Assertions.assertTrue(nodeService.find(node.id()).isPresent()); Assertions.assertTrue(nodeService.find(node.getIdentifier()).isPresent());
Assertions.assertThrows(NodeAlreadyExistException.class, () -> nodeService.create(node)); Assertions.assertThrows(NodeAlreadyExistException.class, () -> nodeService.create(node));
nodeService.remove(node); nodeService.remove(node);
Assertions.assertFalse(() -> nodeService.find(node.id()).isPresent()); Assertions.assertFalse(() -> nodeService.find(node.getIdentifier()).isPresent());
} }
@Test @Test
@ -34,9 +35,9 @@ public class NodeServiceTests {
nodeService.all().forEach(node -> nodeService.remove(node)); nodeService.all().forEach(node -> nodeService.remove(node));
var nodes = List.of( var nodes = List.of(
new Node("test1", PickingMethod.SEQUENTIAL_FILLING, false), new Node(NodeIdentifier.of("test1"), PickingMethod.SEQUENTIAL_FILLING, false),
new Node("test2", PickingMethod.ROUND_ROBIN, false), new Node(NodeIdentifier.of("test2"), PickingMethod.ROUND_ROBIN, false),
new Node("test3", PickingMethod.ROUND_ROBIN, false) new Node(NodeIdentifier.of("test3"), PickingMethod.ROUND_ROBIN, false)
); );
nodes.forEach(node -> nodeService.create(node)); nodes.forEach(node -> nodeService.create(node));

50
server/src/test/java/ru/dragonestia/picker/service/RoomServiceTests.java
View File

@ -10,6 +10,10 @@ import ru.dragonestia.picker.api.exception.NodeNotFoundException;
import ru.dragonestia.picker.api.exception.NotPersistedNodeException; import ru.dragonestia.picker.api.exception.NotPersistedNodeException;
import ru.dragonestia.picker.api.exception.RoomAlreadyExistException; import ru.dragonestia.picker.api.exception.RoomAlreadyExistException;
import ru.dragonestia.picker.api.model.node.PickingMethod; import ru.dragonestia.picker.api.model.node.PickingMethod;
import ru.dragonestia.picker.api.model.room.IRoom;
import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
import ru.dragonestia.picker.api.repository.type.RoomIdentifier;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.Node; import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.model.Room; import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User; import ru.dragonestia.picker.model.User;
@ -30,7 +34,7 @@ public class RoomServiceTests {
@BeforeEach @BeforeEach
void init() { void init() {
node = new Node("test-rooms", PickingMethod.SEQUENTIAL_FILLING, false); node = new Node(NodeIdentifier.of("test-rooms"), PickingMethod.SEQUENTIAL_FILLING, false);
try { try {
nodeService.create(node); nodeService.create(node);
@ -39,24 +43,24 @@ public class RoomServiceTests {
@Test @Test
void test_createAndRemove() { void test_createAndRemove() {
var room = Room.create("test-room", node, SlotLimit.unlimited(), "", false); var room = new Room(RoomIdentifier.of("test-room"), node, IRoom.UNLIMITED_SLOTS, "", false);
roomService.create(room); roomService.create(room);
Assertions.assertTrue(roomService.find(node, room.getId()).isPresent()); Assertions.assertTrue(roomService.find(node, room.getIdentifier()).isPresent());
Assertions.assertThrows(RoomAlreadyExistException.class, () -> roomService.create(room)); Assertions.assertThrows(RoomAlreadyExistException.class, () -> roomService.create(room));
roomService.remove(room); roomService.remove(room);
Assertions.assertFalse(roomService.find(node, room.getId()).isPresent()); Assertions.assertFalse(roomService.find(node, room.getIdentifier()).isPresent());
} }
@Test @Test
void test_allRooms() { void test_allRooms() {
var rooms = List.of( var rooms = List.of(
Room.create("test-room1", node, SlotLimit.of(1), "", false), new Room(RoomIdentifier.of("test-room1"), node, 1, "", false),
Room.create("test-room2", node, SlotLimit.of(2), "", false), new Room(RoomIdentifier.of("test-room2"), node, 2, "", false),
Room.create("test-room3", node, SlotLimit.of(3), "", false), new Room(RoomIdentifier.of("test-room3"), node, 3, "", false),
Room.create("test-room4", node, SlotLimit.unlimited(), "", false) new Room(RoomIdentifier.of("test-room4"), node, IRoom.UNLIMITED_SLOTS, "", false)
); );
rooms.forEach(room -> roomService.create(room)); rooms.forEach(room -> roomService.create(room));
@ -69,27 +73,29 @@ public class RoomServiceTests {
@Test @Test
void test_exceptNotPersistedNode() { void test_exceptNotPersistedNode() {
Assertions.assertThrows(NotPersistedNodeException.class, () -> roomService.create(Room.create("1", node, SlotLimit.unlimited(), "", true))); Assertions.assertThrows(NotPersistedNodeException.class, () -> {
roomService.create(new Room(RoomIdentifier.of("1"), node, IRoom.UNLIMITED_SLOTS, "", true));
});
} }
@Test @Test
void test_pickRoom() { void test_pickRoom() {
var rooms = List.of( var rooms = List.of(
Room.create("test-room1", node, SlotLimit.of(1), "", false), new Room(RoomIdentifier.of("test-room1"), node, 1, "", false),
Room.create("test-room2", node, SlotLimit.of(2), "", false), new Room(RoomIdentifier.of("test-room2"), node, 2, "", false),
Room.create("test-room3", node, SlotLimit.of(3), "", false), new Room(RoomIdentifier.of("test-room3"), node, 3, "", false),
Room.create("test-room4", node, SlotLimit.unlimited(), "", false) new Room(RoomIdentifier.of("test-room4"), node, IRoom.UNLIMITED_SLOTS, "", false)
); );
rooms.forEach(room -> roomService.create(room)); rooms.forEach(room -> roomService.create(room));
var users = List.of( var users = List.of(
new User("1"), new User(UserIdentifier.of("1")),
new User("2"), new User(UserIdentifier.of("2")),
new User("3"), new User(UserIdentifier.of("3")),
new User("4"), new User(UserIdentifier.of("4")),
new User("5"), new User(UserIdentifier.of("5")),
new User("6") new User(UserIdentifier.of("6"))
); );
@ -105,12 +111,12 @@ public class RoomServiceTests {
@Test @Test
void test_nodeDoesNotExists() { void test_nodeDoesNotExists() {
var node = new Node("Bruh", PickingMethod.ROUND_ROBIN, false); var node = new Node(NodeIdentifier.of("bruh"), PickingMethod.ROUND_ROBIN, false);
var room = Room.create("test", node, SlotLimit.unlimited(), "", false); var room = new Room(RoomIdentifier.of("test"), node, IRoom.UNLIMITED_SLOTS, "", false);
Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.create(room)); Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.create(room));
Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.remove(room)); Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.remove(room));
Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.find(node, "Bruh")); Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.find(node, "Bruh"));
Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.pickAvailable(node, List.of(new User("1")))); Assertions.assertThrows(NodeNotFoundException.class, () -> roomService.pickAvailable(node, List.of(new User(UserIdentifier.of("1")))));
} }
} }

3
server/src/test/java/ru/dragonestia/picker/util/UserFiller.java
View File

@ -1,6 +1,7 @@
package ru.dragonestia.picker.util; package ru.dragonestia.picker.util;
import org.springframework.boot.test.context.TestComponent; import org.springframework.boot.test.context.TestComponent;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.User; import ru.dragonestia.picker.model.User;
import java.util.LinkedList; import java.util.LinkedList;
@ -13,7 +14,7 @@ public class UserFiller {
public List<User> createRandomUsers(int amount) { public List<User> createRandomUsers(int amount) {
var list = new LinkedList<User>(); var list = new LinkedList<User>();
for (int i = 0; i < amount; i++) { for (int i = 0; i < amount; i++) {
list.add(new User(UUID.randomUUID().toString())); list.add(new User(UserIdentifier.of(UUID.randomUUID().toString())));
} }
return list; return list;
} }