Fixed tests

ScarletRedMan · Mar 13, 2024 · 65c78df · 65c78df
1 parent c13f566
commit 65c78df
Show file tree

Hide file tree

Showing 8 changed files with 57 additions and 46 deletions.
diff --git a/client-api/src/test/java/util/IdentifierValidatorTests.java b/client-api/src/test/java/util/IdentifierValidatorTests.java
@@ -34,8 +34,8 @@ void test_forRooms() {
         Assertions.assertFalse(IdentifierValidator.forRoom("-"));
         Assertions.assertFalse(IdentifierValidator.forRoom("-a"));
         Assertions.assertFalse(IdentifierValidator.forRoom("a-"));
-        Assertions.assertTrue(IdentifierValidator.forRoom("a".repeat(32)));
-        Assertions.assertFalse(IdentifierValidator.forRoom("a".repeat(33)));
+        Assertions.assertTrue(IdentifierValidator.forRoom("a".repeat(36)));
+        Assertions.assertFalse(IdentifierValidator.forRoom("a".repeat(37)));
     }
 
     @Test

diff --git a/server/src/test/java/ru/dragonestia/picker/config/FillingNodesConfig.java b/server/src/test/java/ru/dragonestia/picker/config/FillingNodesConfig.java
@@ -4,10 +4,12 @@
 import org.springframework.boot.test.context.TestConfiguration;
 import org.springframework.context.annotation.Bean;
 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.Room;
 import ru.dragonestia.picker.model.User;
-import ru.dragonestia.picker.model.type.SlotLimit;
 import ru.dragonestia.picker.repository.NodeRepository;
 import ru.dragonestia.picker.repository.RoomRepository;
 import ru.dragonestia.picker.repository.UserRepository;
@@ -51,7 +53,7 @@ public class FillingNodesConfig {
 
     @Bean
     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);
 
         fillNode(node);
@@ -61,7 +63,7 @@ void createSequentialFillingNode() {
 
     @Bean
     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);
 
         fillNode(node);
@@ -71,7 +73,7 @@ void createRoundRobinNode() {
 
     @Bean
     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);
 
         fillNode(node);
@@ -83,12 +85,12 @@ private void fillNode(Node node) {
         for (int i = 0, n = 5; i < n; i++) {
             for (int j = 0; j < 3; 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);
 
                 var users = n - i;
                 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);
                 }
 

diff --git a/server/src/test/java/ru/dragonestia/picker/picker/LeastPickedTests.java b/server/src/test/java/ru/dragonestia/picker/picker/LeastPickedTests.java
@@ -44,11 +44,11 @@ void testPicking(String expectedRoomId, int usersAmount) {
         Assertions.assertTrue(roomOpt.isPresent());
 
         var room = roomOpt.get();
-        var slots = room.getSlots();
+        var slots = room.getMaxSlots();
         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 {

diff --git a/server/src/test/java/ru/dragonestia/picker/picker/RoundRobinTests.java b/server/src/test/java/ru/dragonestia/picker/picker/RoundRobinTests.java
@@ -8,6 +8,7 @@
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.context.annotation.Import;
+import ru.dragonestia.picker.api.model.node.INode;
 import ru.dragonestia.picker.config.FillingNodesConfig;
 import ru.dragonestia.picker.model.Node;
 import ru.dragonestia.picker.repository.RoomRepository;
@@ -42,11 +43,11 @@ void testPicking(String expectedRoomId, int usersAmount) {
         Assertions.assertTrue(roomOpt.isPresent());
 
         var room = roomOpt.get();
-        var slots = room.getSlots();
+        var slots = room.getMaxSlots();
         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 {

diff --git a/server/src/test/java/ru/dragonestia/picker/picker/SequentialFillingTests.java b/server/src/test/java/ru/dragonestia/picker/picker/SequentialFillingTests.java
@@ -44,11 +44,11 @@ void testPicking(String expectedRoomId, int usersAmount) {
         Assertions.assertTrue(roomOpt.isPresent());
 
         var room = roomOpt.get();
-        var slots = room.getSlots();
+        var slots = room.getMaxSlots();
         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 {

diff --git a/server/src/test/java/ru/dragonestia/picker/service/NodeServiceTests.java b/server/src/test/java/ru/dragonestia/picker/service/NodeServiceTests.java
@@ -6,6 +6,7 @@
 import org.springframework.boot.test.context.SpringBootTest;
 import ru.dragonestia.picker.api.exception.NodeAlreadyExistException;
 import ru.dragonestia.picker.api.model.node.PickingMethod;
+import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
 import ru.dragonestia.picker.model.Node;
 
 import java.util.List;
@@ -18,25 +19,25 @@ public class NodeServiceTests {
 
     @Test
     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.assertTrue(nodeService.find(node.id()).isPresent());
+        Assertions.assertTrue(nodeService.find(node.getIdentifier()).isPresent());
         Assertions.assertThrows(NodeAlreadyExistException.class, () -> nodeService.create(node));
 
         nodeService.remove(node);
 
-        Assertions.assertFalse(() -> nodeService.find(node.id()).isPresent());
+        Assertions.assertFalse(() -> nodeService.find(node.getIdentifier()).isPresent());
     }
 
     @Test
     void test_allNodes() {
         nodeService.all().forEach(node -> nodeService.remove(node));
 
         var nodes = List.of(
-                new Node("test1", PickingMethod.SEQUENTIAL_FILLING, false),
-                new Node("test2", PickingMethod.ROUND_ROBIN, false),
-                new Node("test3", PickingMethod.ROUND_ROBIN, false)
+                new Node(NodeIdentifier.of("test1"), PickingMethod.SEQUENTIAL_FILLING, false),
+                new Node(NodeIdentifier.of("test2"), PickingMethod.ROUND_ROBIN, false),
+                new Node(NodeIdentifier.of("test3"), PickingMethod.ROUND_ROBIN, false)
         );
 
         nodes.forEach(node -> nodeService.create(node));

diff --git a/server/src/test/java/ru/dragonestia/picker/service/RoomServiceTests.java b/server/src/test/java/ru/dragonestia/picker/service/RoomServiceTests.java
@@ -10,6 +10,10 @@
 import ru.dragonestia.picker.api.exception.NotPersistedNodeException;
 import ru.dragonestia.picker.api.exception.RoomAlreadyExistException;
 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.Room;
 import ru.dragonestia.picker.model.User;
@@ -30,7 +34,7 @@ public class RoomServiceTests {
 
     @BeforeEach
     void init() {
-        node = new Node("test-rooms", PickingMethod.SEQUENTIAL_FILLING, false);
+        node = new Node(NodeIdentifier.of("test-rooms"), PickingMethod.SEQUENTIAL_FILLING, false);
 
         try {
             nodeService.create(node);
@@ -39,24 +43,24 @@ void init() {
 
     @Test
     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);
 
-        Assertions.assertTrue(roomService.find(node, room.getId()).isPresent());
+        Assertions.assertTrue(roomService.find(node, room.getIdentifier()).isPresent());
         Assertions.assertThrows(RoomAlreadyExistException.class, () -> roomService.create(room));
 
         roomService.remove(room);
 
-        Assertions.assertFalse(roomService.find(node, room.getId()).isPresent());
+        Assertions.assertFalse(roomService.find(node, room.getIdentifier()).isPresent());
     }
 
     @Test
     void test_allRooms() {
         var rooms = List.of(
-                Room.create("test-room1", node, SlotLimit.of(1), "", false),
-                Room.create("test-room2", node, SlotLimit.of(2), "", false),
-                Room.create("test-room3", node, SlotLimit.of(3), "", false),
-                Room.create("test-room4", node, SlotLimit.unlimited(), "", false)
+                new Room(RoomIdentifier.of("test-room1"), node, 1, "", false),
+                new Room(RoomIdentifier.of("test-room2"), node, 2, "", false),
+                new Room(RoomIdentifier.of("test-room3"), node, 3, "", false),
+                new Room(RoomIdentifier.of("test-room4"), node, IRoom.UNLIMITED_SLOTS, "", false)
         );
 
         rooms.forEach(room -> roomService.create(room));
@@ -69,27 +73,29 @@ void test_allRooms() {
 
     @Test
     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
     void test_pickRoom() {
         var rooms = List.of(
-                Room.create("test-room1", node, SlotLimit.of(1), "", false),
-                Room.create("test-room2", node, SlotLimit.of(2), "", false),
-                Room.create("test-room3", node, SlotLimit.of(3), "", false),
-                Room.create("test-room4", node, SlotLimit.unlimited(), "", false)
+                new Room(RoomIdentifier.of("test-room1"), node, 1, "", false),
+                new Room(RoomIdentifier.of("test-room2"), node, 2, "", false),
+                new Room(RoomIdentifier.of("test-room3"), node, 3, "", false),
+                new Room(RoomIdentifier.of("test-room4"), node, IRoom.UNLIMITED_SLOTS, "", false)
         );
 
         rooms.forEach(room -> roomService.create(room));
 
         var users = List.of(
-                new User("1"),
-                new User("2"),
-                new User("3"),
-                new User("4"),
-                new User("5"),
-                new User("6")
+                new User(UserIdentifier.of("1")),
+                new User(UserIdentifier.of("2")),
+                new User(UserIdentifier.of("3")),
+                new User(UserIdentifier.of("4")),
+                new User(UserIdentifier.of("5")),
+                new User(UserIdentifier.of("6"))
         );
 
 
@@ -105,12 +111,12 @@ void test_removeNode() {
 
     @Test
     void test_nodeDoesNotExists() {
-        var node = new Node("Bruh", PickingMethod.ROUND_ROBIN, false);
-        var room = Room.create("test", node, SlotLimit.unlimited(), "", false);
+        var node = new Node(NodeIdentifier.of("bruh"), PickingMethod.ROUND_ROBIN, 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.remove(room));
         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")))));
     }
 }
diff --git a/server/src/test/java/ru/dragonestia/picker/util/UserFiller.java b/server/src/test/java/ru/dragonestia/picker/util/UserFiller.java
@@ -1,6 +1,7 @@
 package ru.dragonestia.picker.util;
 
 import org.springframework.boot.test.context.TestComponent;
+import ru.dragonestia.picker.api.repository.type.UserIdentifier;
 import ru.dragonestia.picker.model.User;
 
 import java.util.LinkedList;
@@ -13,7 +14,7 @@ public class UserFiller {
     public List<User> createRandomUsers(int amount) {
         var list = new LinkedList<User>();
         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;
     }