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.boot:spring-boot-starter-test'
testImplementation 'org.springframework.security:spring-security-test' testImplementation 'org.springframework.security:spring-security-test'
testImplementation 'org.mockito:mockito-junit-jupiter:4.2.0' testImplementation 'org.mockito:mockito-junit-jupiter:4.2.0'
testImplementation project(":client-api")
} }
tasks.named('bootBuildImage') { 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.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.model.entity.EntityId;
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.instance.Instance; import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.model.entity.Entity; 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.model.room.factory.RoomFactory;
import ru.dragonestia.picker.repository.InstanceRepository; import ru.dragonestia.picker.repository.InstanceRepository;
import ru.dragonestia.picker.repository.RoomRepository; import ru.dragonestia.picker.repository.RoomRepository;
@ -56,7 +56,7 @@ public class FillingNodesConfig {
@Bean @Bean
void createSequentialFillingNode() { 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); instanceRepository.create(node);
fillNode(node); fillNode(node);
@ -66,7 +66,7 @@ public class FillingNodesConfig {
@Bean @Bean
void createRoundRobinNode() { 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); instanceRepository.create(node);
fillNode(node); fillNode(node);
@ -76,7 +76,7 @@ public class FillingNodesConfig {
@Bean @Bean
void createLeastPickerNode() { 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); instanceRepository.create(node);
fillNode(node); fillNode(node);
@ -88,12 +88,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 = roomFactory.create(RoomIdentifier.of(roomId), instance, n, "", false); var room = roomFactory.create(RoomId.of(roomId), instance, 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 Entity(EntityIdentifier.of("user-" + k)); var user = EntityId.of("user-" + k);
entityRepository.linkWithRoom(room, List.of(user), false); 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.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.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.config.FillingNodesConfig; import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.model.instance.Instance; 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.RoomRepository;
import ru.dragonestia.picker.repository.EntityRepository; import ru.dragonestia.picker.repository.EntityRepository;
import ru.dragonestia.picker.util.UserFiller; import ru.dragonestia.picker.util.UserFiller;
@ -41,15 +42,15 @@ public class LeastPickedTests {
@ParameterizedTest @ParameterizedTest
@ArgumentsSource(PickingArgumentProvider.class) @ArgumentsSource(PickingArgumentProvider.class)
void testPicking(String expectedRoomId, int usersAmount) { 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 room = roomRepository.pick(instance.getId(), userFiller.createRandomUsers(usersAmount));
var slots = room.getMaxSlots(); var slots = room.getSlots();
var users = entityRepository.entitiesOf(room); var users = entityRepository.entitiesOf(room);
Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation 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); 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 { public static class PickingArgumentProvider implements ArgumentsProvider {
@ -74,6 +75,6 @@ public class LeastPickedTests {
@Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD) @Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
@Test @Test
void testNoOneRoomExpected() { // Take 9 users. expected none result 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.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.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.config.FillingNodesConfig; import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.model.instance.Instance; import ru.dragonestia.picker.model.instance.Instance;
import ru.dragonestia.picker.repository.RoomRepository; import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.EntityRepository; import ru.dragonestia.picker.repository.EntityRepository;
@ -39,12 +39,12 @@ public class RoundRobinTests {
@ParameterizedTest @ParameterizedTest
@ArgumentsSource(PickingArgumentProvider.class) @ArgumentsSource(PickingArgumentProvider.class)
void testPicking(String expectedRoomId, int usersAmount) { void testPicking(String expectedRoomId, int usersAmount) {
var room = roomRepository.pick(instance, userFiller.createRandomUsers(usersAmount)); var room = roomRepository.pick(instance.getId(), userFiller.createRandomUsers(usersAmount));
var slots = room.getMaxSlots(); var slots = room.getSlots();
var users = entityRepository.entitiesOf(room); var users = entityRepository.entitiesOf(room);
Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation 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 { public static class PickingArgumentProvider implements ArgumentsProvider {
@ -66,6 +66,6 @@ public class RoundRobinTests {
@Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD) @Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
@Test @Test
void testNoOneRoomExpected() { // Take 9 users. expected none result 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.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.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.config.FillingNodesConfig; import ru.dragonestia.picker.config.FillingNodesConfig;
import ru.dragonestia.picker.exception.NoRoomsAvailableException;
import ru.dragonestia.picker.model.instance.Instance; 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.RoomRepository;
import ru.dragonestia.picker.repository.EntityRepository; import ru.dragonestia.picker.repository.EntityRepository;
import ru.dragonestia.picker.util.UserFiller; import ru.dragonestia.picker.util.UserFiller;
@ -41,15 +42,15 @@ public class SequentialFillingTests {
@ParameterizedTest @ParameterizedTest
@ArgumentsSource(PickingArgumentProvider.class) @ArgumentsSource(PickingArgumentProvider.class)
void testPicking(String expectedRoomId, int usersAmount) { 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 room = roomRepository.pick(instance.getId(), userFiller.createRandomUsers(usersAmount));
var slots = room.getMaxSlots(); var slots = room.getSlots();
var users = entityRepository.entitiesOf(room); var users = entityRepository.entitiesOf(room);
Assertions.assertTrue(slots == -1 || slots >= users.size()); // check slots limitation 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); 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 { public static class PickingArgumentProvider implements ArgumentsProvider {
@ -71,6 +72,6 @@ public class SequentialFillingTests {
@Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD) @Timeout(value = 1, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
@Test @Test
void testNoOneRoomExpected() { // Take 9 users. expected none result 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.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser; import org.springframework.security.test.context.support.WithMockUser;
import ru.dragonestia.picker.api.exception.InstanceAlreadyExistException; import ru.dragonestia.picker.exception.AlreadyExistsException;
import ru.dragonestia.picker.api.model.node.PickingMethod;
import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
import ru.dragonestia.picker.model.instance.Instance; 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; import java.util.List;
@ -21,13 +21,13 @@ public class InstanceServiceTests {
@WithMockUser(roles = {"NODE_MANAGEMENT"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_nodeCreateAndRemove() { 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.assertDoesNotThrow(() -> instanceService.create(node));
Assertions.assertTrue(instanceService.find(node.getId()).isPresent()); 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()); Assertions.assertFalse(() -> instanceService.find(node.getId()).isPresent());
} }
@ -35,12 +35,12 @@ public class InstanceServiceTests {
@WithMockUser(roles = {"NODE_MANAGEMENT"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_allNodes() { void test_allNodes() {
instanceService.all().forEach(node -> instanceService.remove(node)); instanceService.all().forEach(node -> instanceService.remove(node.getId()));
var nodes = List.of( var nodes = List.of(
new Instance(NodeIdentifier.of("test1"), PickingMethod.SEQUENTIAL_FILLING, false), new Instance(InstanceId.of("test1"), PickingMethod.SEQUENTIAL_FILLING, false),
new Instance(NodeIdentifier.of("test2"), PickingMethod.ROUND_ROBIN, false), new Instance(InstanceId.of("test2"), PickingMethod.ROUND_ROBIN, false),
new Instance(NodeIdentifier.of("test3"), PickingMethod.ROUND_ROBIN, false) new Instance(InstanceId.of("test3"), PickingMethod.ROUND_ROBIN, false)
); );
nodes.forEach(node -> instanceService.create(node)); nodes.forEach(node -> instanceService.create(node));
@ -50,7 +50,7 @@ public class InstanceServiceTests {
Assertions.assertEquals(nodes.size(), list.size()); Assertions.assertEquals(nodes.size(), list.size());
Assertions.assertTrue(list.containsAll(nodes)); Assertions.assertTrue(list.containsAll(nodes));
nodes.forEach(node -> instanceService.remove(node)); nodes.forEach(node -> instanceService.remove(node.getId()));
Assertions.assertEquals(0, instanceService.all().size()); 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.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser; import org.springframework.security.test.context.support.WithMockUser;
import ru.dragonestia.picker.api.exception.InstanceAlreadyExistException; import ru.dragonestia.picker.exception.AlreadyExistsException;
import ru.dragonestia.picker.api.exception.InstanceNotFoundException; import ru.dragonestia.picker.exception.ConflictingPersistParametersException;
import ru.dragonestia.picker.api.exception.NotPersistedNodeException; import ru.dragonestia.picker.exception.DoesNotExistsException;
import ru.dragonestia.picker.api.exception.RoomAlreadyExistException; import ru.dragonestia.picker.model.entity.EntityId;
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.model.instance.Instance; 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.model.room.factory.RoomFactory;
import java.util.List; import java.util.List;
@ -38,40 +35,40 @@ public class RoomServiceTests {
@BeforeEach @BeforeEach
void init() { 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 { try {
instanceService.create(instance); instanceService.create(instance);
} catch (InstanceAlreadyExistException ignore) {} } catch (AlreadyExistsException ignore) {}
} }
@WithMockUser(roles = {"NODE_MANAGEMENT"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_createAndRemove() { 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); roomService.create(room);
Assertions.assertTrue(roomService.find(instance, room.getId()).isPresent()); Assertions.assertTrue(roomService.find(instance.getId(), room.getId()).isPresent());
Assertions.assertThrows(RoomAlreadyExistException.class, () -> roomService.create(room)); Assertions.assertThrows(AlreadyExistsException.class, () -> roomService.create(room));
roomService.remove(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"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_allRooms() { void test_allRooms() {
var rooms = List.of( var rooms = List.of(
roomFactory.create(RoomIdentifier.of("test-room1"), instance, 1, "", false), roomFactory.create(RoomId.of("test-room1"), instance, 1, "", false),
roomFactory.create(RoomIdentifier.of("test-room2"), instance, 2, "", false), roomFactory.create(RoomId.of("test-room2"), instance, 2, "", false),
roomFactory.create(RoomIdentifier.of("test-room3"), instance, 3, "", false), roomFactory.create(RoomId.of("test-room3"), instance, 3, "", false),
roomFactory.create(RoomIdentifier.of("test-room4"), instance, IRoom.UNLIMITED_SLOTS, "", false) roomFactory.create(RoomId.of("test-room4"), instance, -1, "", false)
); );
rooms.forEach(room -> roomService.create(room)); rooms.forEach(room -> roomService.create(room));
var list = roomService.all(instance); var list = roomService.all(instance.getId());
Assertions.assertEquals(rooms.size(), list.size()); Assertions.assertEquals(rooms.size(), list.size());
Assertions.assertTrue(rooms.containsAll(list)); Assertions.assertTrue(rooms.containsAll(list));
@ -80,8 +77,8 @@ public class RoomServiceTests {
@WithMockUser(roles = {"NODE_MANAGEMENT"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_exceptNotPersistedNode() { void test_exceptNotPersistedNode() {
Assertions.assertThrows(NotPersistedNodeException.class, () -> { Assertions.assertThrows(ConflictingPersistParametersException.class, () -> {
roomService.create(roomFactory.create(RoomIdentifier.of("1"), instance, IRoom.UNLIMITED_SLOTS, "", true)); roomService.create(roomFactory.create(RoomId.of("1"), instance, -1, "", true));
}); });
} }
@ -89,44 +86,44 @@ public class RoomServiceTests {
@Test @Test
void test_pickRoom() { void test_pickRoom() {
var rooms = List.of( var rooms = List.of(
roomFactory.create(RoomIdentifier.of("test-room1"), instance, 1, "", false), roomFactory.create(RoomId.of("test-room1"), instance, 1, "", false),
roomFactory.create(RoomIdentifier.of("test-room2"), instance, 2, "", false), roomFactory.create(RoomId.of("test-room2"), instance, 2, "", false),
roomFactory.create(RoomIdentifier.of("test-room3"), instance, 3, "", false), roomFactory.create(RoomId.of("test-room3"), instance, 3, "", false),
roomFactory.create(RoomIdentifier.of("test-room4"), instance, IRoom.UNLIMITED_SLOTS, "", false) roomFactory.create(RoomId.of("test-room4"), instance, -1, "", false)
); );
rooms.forEach(room -> roomService.create(room)); rooms.forEach(room -> roomService.create(room));
var users = Set.of( var users = Set.of(
new Entity(EntityIdentifier.of("1")), EntityId.of("1"),
new Entity(EntityIdentifier.of("2")), EntityId.of("2"),
new Entity(EntityIdentifier.of("3")), EntityId.of("3"),
new Entity(EntityIdentifier.of("4")), EntityId.of("4"),
new Entity(EntityIdentifier.of("5")), EntityId.of("5"),
new Entity(EntityIdentifier.of("6")) 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"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_removeNode() { 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"}) @WithMockUser(roles = {"NODE_MANAGEMENT"})
@Test @Test
void test_nodeDoesNotExists() { void test_nodeDoesNotExists() {
var node = new Instance(NodeIdentifier.of("bruh"), PickingMethod.ROUND_ROBIN, false); var node = new Instance(InstanceId.of("bruh"), PickingMethod.ROUND_ROBIN, false);
var room = roomFactory.create(RoomIdentifier.of("test"), node, IRoom.UNLIMITED_SLOTS, "", false); var room = roomFactory.create(RoomId.of("test"), node, -1, "", false);
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.create(room)); Assertions.assertThrows(DoesNotExistsException.class, () -> roomService.create(room));
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.remove(room)); Assertions.assertThrows(DoesNotExistsException.class, () -> roomService.remove(room));
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.find(node, "Bruh")); Assertions.assertThrows(RuntimeException.class, () -> roomService.find(node.getId(), RoomId.of("Bruh")).orElseThrow());
Assertions.assertThrows(InstanceNotFoundException.class, () -> roomService.pick(node, Set.of(new Entity(EntityIdentifier.of("1"))))); 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; 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.EntityIdentifier; import ru.dragonestia.picker.model.entity.EntityId;
import ru.dragonestia.picker.model.entity.Entity;
import java.util.*; import java.util.*;
@TestComponent @TestComponent
public class UserFiller { public class UserFiller {
public Set<Entity> createRandomUsers(int amount) { public Set<EntityId> createRandomUsers(int amount) {
var set = new HashSet<Entity>(); var set = new HashSet<EntityId>();
for (int i = 0; i < amount; i++) { 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; return set;
} }