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

fixed tests
All checks were successful
Build Project / build (push) Successful in 9m0s
Details

Browse Source
This commit is contained in:
Andrey Terentev 2024-05-27 10:12:11 +07:00 committed by Andrey Terentev
parent 93226022b2
commit bebba7f87d
8 changed files with 83 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
server/build.gradle
View File

@ -28,6 +28,7 @@ dependencies {
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.security:spring-security-test'
testImplementation 'org.mockito:mockito-junit-jupiter:4.2.0'
testImplementation project(":client-api")
}
tasks.named('bootBuildImage') {

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

@ -3,12 +3,12 @@ package ru.dragonestia.picker.config;
import org.springframework.beans.factory.annotation.Autowired;
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.EntityIdentifier;
import ru.dragonestia.picker.model.entity.EntityId;
import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.model.entity.Entity;
import ru.dragonestia.picker.model.instance.InstanceId;
import ru.dragonestia.picker.model.instance.type.PickingMethod;
import ru.dragonestia.picker.model.room.RoomId;
import ru.dragonestia.picker.model.room.factory.RoomFactory;
import ru.dragonestia.picker.repository.InstanceRepository;
import ru.dragonestia.picker.repository.RoomRepository;
@ -56,7 +56,7 @@ public class FillingNodesConfig {
@Bean
void createSequentialFillingNode() {
var node = new Instance(NodeIdentifier.of("seq"), PickingMethod.SEQUENTIAL_FILLING, false);
var node = new Instance(InstanceId.of("seq"), PickingMethod.SEQUENTIAL_FILLING, false);
instanceRepository.create(node);
fillNode(node);
@ -66,7 +66,7 @@ public class FillingNodesConfig {
@Bean
void createRoundRobinNode() {
var node = new Instance(NodeIdentifier.of("round"), PickingMethod.ROUND_ROBIN, false);
var node = new Instance(InstanceId.of("round"), PickingMethod.ROUND_ROBIN, false);
instanceRepository.create(node);
fillNode(node);
@ -76,7 +76,7 @@ public class FillingNodesConfig {
@Bean
void createLeastPickerNode() {
var node = new Instance(NodeIdentifier.of("least"), PickingMethod.LEAST_PICKED, false);
var node = new Instance(InstanceId.of("least"), PickingMethod.LEAST_PICKED, false);
instanceRepository.create(node);
fillNode(node);
@ -88,12 +88,12 @@ public class FillingNodesConfig {
for (int i = 0, n = 5; i < n; i++) {
for (int j = 0; j < 3; j++) {
var roomId = "room-" + i + "-" + j;
var room = roomFactory.create(RoomIdentifier.of(roomId), instance, n, "", false);
var room = roomFactory.create(RoomId.of(roomId), instance, n, "", false);
roomRepository.create(room);
var users = n - i;
for (int k = users - 1; k >= 0; k--) {
var user = new Entity(EntityIdentifier.of("user-" + k));
var user = EntityId.of("user-" + k);
entityRepository.linkWithRoom(room, List.of(user), false);
}

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

@ -10,9 +10,10 @@ import org.springframework.beans.factory.annotation.Autowired;
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.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.model.room.RoomId;
import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.EntityRepository;
import ru.dragonestia.picker.util.UserFiller;
@ -41,15 +42,15 @@ public class LeastPickedTests {
@ParameterizedTest
@ArgumentsSource(PickingArgumentProvider.class)
void testPicking(String expectedRoomId, int usersAmount) {
var expectedRoomUsers = entityRepository.entitiesOf(roomRepository.find(instance, expectedRoomId).orElseThrow()).size();
var expectedRoomUsers = entityRepository.entitiesOf(roomRepository.find(instance.getId(), RoomId.of(expectedRoomId)).orElseThrow()).size();
var room = roomRepository.pick(instance, userFiller.createRandomUsers(usersAmount));
var slots = room.getMaxSlots();
var room = roomRepository.pick(instance.getId(), userFiller.createRandomUsers(usersAmount));
var slots = room.getSlots();
var users = entityRepository.entitiesOf(room);
Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation
System.out.printf("Room(%s) has %s/%s users. Expected: %s(%s), added: %s%n", room.getId(), users.size(), slots, expectedRoomId, expectedRoomUsers, usersAmount);
Assertions.assertEquals(expectedRoomId, room.getId());
Assertions.assertEquals(expectedRoomId, room.getId().getValue());
}
public static class PickingArgumentProvider implements ArgumentsProvider {
@ -74,6 +75,6 @@ public class LeastPickedTests {
@Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
@Test
void testNoOneRoomExpected() { // Take 9 users. expected none result
Assertions.assertThrows(NoRoomsAvailableException.class, () -> roomRepository.pick(instance, userFiller.createRandomUsers(9)));
Assertions.assertThrows(NoRoomsAvailableException.class, () -> roomRepository.pick(instance.getId(), userFiller.createRandomUsers(9)));
}
}

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

@ -8,8 +8,8 @@ import org.springframework.beans.factory.annotation.Autowired;
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.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.EntityRepository;
@ -39,12 +39,12 @@ public class RoundRobinTests {
@ParameterizedTest
@ArgumentsSource(PickingArgumentProvider.class)
void testPicking(String expectedRoomId, int usersAmount) {
var room = roomRepository.pick(instance, userFiller.createRandomUsers(usersAmount));
var slots = room.getMaxSlots();
var room = roomRepository.pick(instance.getId(), userFiller.createRandomUsers(usersAmount));
var slots = room.getSlots();
var users = entityRepository.entitiesOf(room);
Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation
Assertions.assertEquals(expectedRoomId, room.getId());
Assertions.assertEquals(expectedRoomId, room.getId().getValue());
}
public static class PickingArgumentProvider implements ArgumentsProvider {
@ -66,6 +66,6 @@ public class RoundRobinTests {
@Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
@Test
void testNoOneRoomExpected() { // Take 9 users. expected none result
Assertions.assertThrows(NoRoomsAvailableException.class, () -> roomRepository.pick(instance, userFiller.createRandomUsers(9)));
Assertions.assertThrows(NoRoomsAvailableException.class, () -> roomRepository.pick(instance.getId(), userFiller.createRandomUsers(9)));
}
}

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

@ -10,9 +10,10 @@ import org.springframework.beans.factory.annotation.Autowired;
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.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.model.room.RoomId;
import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.EntityRepository;
import ru.dragonestia.picker.util.UserFiller;
@ -41,15 +42,15 @@ public class SequentialFillingTests {
@ParameterizedTest
@ArgumentsSource(PickingArgumentProvider.class)
void testPicking(String expectedRoomId, int usersAmount) {
var expectedRoomUsers = entityRepository.entitiesOf(roomRepository.find(instance, expectedRoomId).orElseThrow()).size();
var expectedRoomUsers = entityRepository.entitiesOf(roomRepository.find(instance.getId(), RoomId.of(expectedRoomId)).orElseThrow()).size();
var room = roomRepository.pick(instance, userFiller.createRandomUsers(usersAmount));
var slots = room.getMaxSlots();
var room = roomRepository.pick(instance.getId(), userFiller.createRandomUsers(usersAmount));
var slots = room.getSlots();
var users = entityRepository.entitiesOf(room);
Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation
System.out.printf("Room(%s) has %s/%s users. Expected: %s(%s), added: %s%n", room.getId(), users.size(), slots, expectedRoomId, expectedRoomUsers, usersAmount);
Assertions.assertEquals(expectedRoomId, room.getId());
Assertions.assertEquals(expectedRoomId, room.getId().getValue());
}
public static class PickingArgumentProvider implements ArgumentsProvider {
@ -71,6 +72,6 @@ public class SequentialFillingTests {
@Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
@Test
void testNoOneRoomExpected() { // Take 9 users. expected none result
Assertions.assertThrows(NoRoomsAvailableException.class, () -> roomRepository.pick(instance, userFiller.createRandomUsers(9)));
Assertions.assertThrows(NoRoomsAvailableException.class, () -> roomRepository.pick(instance.getId(), userFiller.createRandomUsers(9)));
}
}

22
server/src/test/java/ru/dragonestia/picker/service/InstanceServiceTests.java
View File

@ -5,10 +5,10 @@ import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser;
import ru.dragonestia.picker.api.exception.InstanceAlreadyExistException;
import ru.dragonestia.picker.api.model.node.PickingMethod;
import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
import ru.dragonestia.picker.exception.AlreadyExistsException;
import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.model.instance.InstanceId;
import ru.dragonestia.picker.model.instance.type.PickingMethod;
import java.util.List;
@ -21,13 +21,13 @@ public class InstanceServiceTests {
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_nodeCreateAndRemove() {
var node = new Instance(NodeIdentifier.of("test"), PickingMethod.SEQUENTIAL_FILLING, false);
var node = new Instance(InstanceId.of("test"), PickingMethod.SEQUENTIAL_FILLING, false);
Assertions.assertDoesNotThrow(() -> instanceService.create(node));
Assertions.assertTrue(instanceService.find(node.getId()).isPresent());
Assertions.assertThrows(InstanceAlreadyExistException.class, () -> instanceService.create(node));
Assertions.assertThrows(AlreadyExistsException.class, () -> instanceService.create(node));
instanceService.remove(node);
instanceService.remove(node.getId());
Assertions.assertFalse(() -> instanceService.find(node.getId()).isPresent());
}
@ -35,12 +35,12 @@ public class InstanceServiceTests {
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_allNodes() {
instanceService.all().forEach(node -> instanceService.remove(node));
instanceService.all().forEach(node -> instanceService.remove(node.getId()));
var nodes = List.of(
new Instance(NodeIdentifier.of("test1"), PickingMethod.SEQUENTIAL_FILLING, false),
new Instance(NodeIdentifier.of("test2"), PickingMethod.ROUND_ROBIN, false),
new Instance(NodeIdentifier.of("test3"), PickingMethod.ROUND_ROBIN, false)
new Instance(InstanceId.of("test1"), PickingMethod.SEQUENTIAL_FILLING, false),
new Instance(InstanceId.of("test2"), PickingMethod.ROUND_ROBIN, false),
new Instance(InstanceId.of("test3"), PickingMethod.ROUND_ROBIN, false)
);
nodes.forEach(node -> instanceService.create(node));
@ -50,7 +50,7 @@ public class InstanceServiceTests {
Assertions.assertEquals(nodes.size(), list.size());
Assertions.assertTrue(list.containsAll(nodes));
nodes.forEach(node -> instanceService.remove(node));
nodes.forEach(node -> instanceService.remove(node.getId()));
Assertions.assertEquals(0, instanceService.all().size());
}

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

@ -6,17 +6,14 @@ import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser;
import ru.dragonestia.picker.api.exception.InstanceAlreadyExistException;
import ru.dragonestia.picker.api.exception.InstanceNotFoundException;
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.EntityIdentifier;
import ru.dragonestia.picker.exception.AlreadyExistsException;
import ru.dragonestia.picker.exception.ConflictingPersistParametersException;
import ru.dragonestia.picker.exception.DoesNotExistsException;
import ru.dragonestia.picker.model.entity.EntityId;
import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.model.entity.Entity;
import ru.dragonestia.picker.model.instance.InstanceId;
import ru.dragonestia.picker.model.instance.type.PickingMethod;
import ru.dragonestia.picker.model.room.RoomId;
import ru.dragonestia.picker.model.room.factory.RoomFactory;
import java.util.List;
@ -38,40 +35,40 @@ public class RoomServiceTests {
@BeforeEach
void init() {
instance = new Instance(NodeIdentifier.of("test-rooms"), PickingMethod.SEQUENTIAL_FILLING, false);
instance = new Instance(InstanceId.of("test-rooms"), PickingMethod.SEQUENTIAL_FILLING, false);
try {
instanceService.create(instance);
} catch (InstanceAlreadyExistException ignore) {}
} catch (AlreadyExistsException ignore) {}
}
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_createAndRemove() {
var room = roomFactory.create(RoomIdentifier.of("test-room"), instance, IRoom.UNLIMITED_SLOTS, "", false);
var room = roomFactory.create(RoomId.of("test-room"), instance, -1, "", false);
roomService.create(room);
Assertions.assertTrue(roomService.find(instance, room.getId()).isPresent());
Assertions.assertThrows(RoomAlreadyExistException.class, () -> roomService.create(room));
Assertions.assertTrue(roomService.find(instance.getId(), room.getId()).isPresent());
Assertions.assertThrows(AlreadyExistsException.class, () -> roomService.create(room));
roomService.remove(room);
Assertions.assertFalse(roomService.find(instance, room.getId()).isPresent());
Assertions.assertFalse(roomService.find(instance.getId(), room.getId()).isPresent());
}
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_allRooms() {
var rooms = List.of(
roomFactory.create(RoomIdentifier.of("test-room1"), instance, 1, "", false),
roomFactory.create(RoomIdentifier.of("test-room2"), instance, 2, "", false),
roomFactory.create(RoomIdentifier.of("test-room3"), instance, 3, "", false),
roomFactory.create(RoomIdentifier.of("test-room4"), instance, IRoom.UNLIMITED_SLOTS, "", false)
roomFactory.create(RoomId.of("test-room1"), instance, 1, "", false),
roomFactory.create(RoomId.of("test-room2"), instance, 2, "", false),
roomFactory.create(RoomId.of("test-room3"), instance, 3, "", false),
roomFactory.create(RoomId.of("test-room4"), instance, -1, "", false)
);
rooms.forEach(room -> roomService.create(room));
var list = roomService.all(instance);
var list = roomService.all(instance.getId());
Assertions.assertEquals(rooms.size(), list.size());
Assertions.assertTrue(rooms.containsAll(list));
@ -80,8 +77,8 @@ public class RoomServiceTests {
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_exceptNotPersistedNode() {
Assertions.assertThrows(NotPersistedNodeException.class, () -> {
roomService.create(roomFactory.create(RoomIdentifier.of("1"), instance, IRoom.UNLIMITED_SLOTS, "", true));
Assertions.assertThrows(ConflictingPersistParametersException.class, () -> {
roomService.create(roomFactory.create(RoomId.of("1"), instance, -1, "", true));
});
}
@ -89,44 +86,44 @@ public class RoomServiceTests {
@Test
void test_pickRoom() {
var rooms = List.of(
roomFactory.create(RoomIdentifier.of("test-room1"), instance, 1, "", false),
roomFactory.create(RoomIdentifier.of("test-room2"), instance, 2, "", false),
roomFactory.create(RoomIdentifier.of("test-room3"), instance, 3, "", false),
roomFactory.create(RoomIdentifier.of("test-room4"), instance, IRoom.UNLIMITED_SLOTS, "", false)
roomFactory.create(RoomId.of("test-room1"), instance, 1, "", false),
roomFactory.create(RoomId.of("test-room2"), instance, 2, "", false),
roomFactory.create(RoomId.of("test-room3"), instance, 3, "", false),
roomFactory.create(RoomId.of("test-room4"), instance, -1, "", false)
);
rooms.forEach(room -> roomService.create(room));
var users = Set.of(
new Entity(EntityIdentifier.of("1")),
new Entity(EntityIdentifier.of("2")),
new Entity(EntityIdentifier.of("3")),
new Entity(EntityIdentifier.of("4")),
new Entity(EntityIdentifier.of("5")),
new Entity(EntityIdentifier.of("6"))
EntityId.of("1"),
EntityId.of("2"),
EntityId.of("3"),
EntityId.of("4"),
EntityId.of("5"),
EntityId.of("6")
);
Assertions.assertEquals("test-room4", roomService.pick(instance, users).roomId());
Assertions.assertEquals("test-room4", roomService.pick(instance.getId(), users).getId().getValue());
}
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_removeNode() {
instanceService.remove(instance);
instanceService.remove(instance.getId());
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.all(instance));
Assertions.assertThrows(DoesNotExistsException.class, () -> roomService.all(instance.getId()));
}
@WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test
void test_nodeDoesNotExists() {
var node = new Instance(NodeIdentifier.of("bruh"), PickingMethod.ROUND_ROBIN, false);
var room = roomFactory.create(RoomIdentifier.of("test"), node, IRoom.UNLIMITED_SLOTS, "", false);
var node = new Instance(InstanceId.of("bruh"), PickingMethod.ROUND_ROBIN, false);
var room = roomFactory.create(RoomId.of("test"), node, -1, "", false);
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.create(room));
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.remove(room));
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.find(node, "Bruh"));
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.pick(node, Set.of(new Entity(EntityIdentifier.of("1")))));
Assertions.assertThrows(DoesNotExistsException.class, () -> roomService.create(room));
Assertions.assertThrows(DoesNotExistsException.class, () -> roomService.remove(room));
Assertions.assertThrows(RuntimeException.class, () -> roomService.find(node.getId(), RoomId.of("Bruh")).orElseThrow());
Assertions.assertThrows(DoesNotExistsException.class, () -> roomService.pick(node.getId(), Set.of(EntityId.of("1"))));
}
}

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

@ -1,18 +1,17 @@
package ru.dragonestia.picker.util;
import org.springframework.boot.test.context.TestComponent;
import ru.dragonestia.picker.api.repository.type.EntityIdentifier;
import ru.dragonestia.picker.model.entity.Entity;
import ru.dragonestia.picker.model.entity.EntityId;
import java.util.*;
@TestComponent
public class UserFiller {
public Set<Entity> createRandomUsers(int amount) {
var set = new HashSet<Entity>();
public Set<EntityId> createRandomUsers(int amount) {
var set = new HashSet<EntityId>();
for (int i = 0; i < amount; i++) {
set.add(new Entity(EntityIdentifier.of(UUID.randomUUID().toString())));
set.add(EntityId.of(UUID.randomUUID().toString()));
}
return set;
}