Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-01-27 23:09:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-165] removing mocking utils and general test improvements

Browse Source
This commit is contained in:
Sheldan
2021-02-28 21:46:45 +01:00
parent 5f6746d742
commit 821971523e
55 changed files with 834 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceRoleServiceBean.java
View File

@@ -123,7 +123,7 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
if(roles == null || roles.isEmpty()) {
return null;
}
log.trace("Calculating role for level {} in server {}. Using {} roles in our config.", currentLevel, roles.get(0).getRoleServer().getId(), roles.size());
log.trace("Calculating role for level {} in server {}. Using {} roles in our config.", currentLevel, roles.get(0).getServer().getId(), roles.size());
AExperienceRole lastRole = null;
for (AExperienceRole experienceRole : roles) {
if(currentLevel >= experienceRole.getLevel().getLevel()) {

2
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/DisabledExpRoleManagementServiceBean.java
View File

@@ -23,7 +23,7 @@ public class DisabledExpRoleManagementServiceBean implements DisabledExpRoleMana
.builder()
.role(role)
.build();
log.info("Adding disabled exp role {} for server {}.", role.getId(),role.getServer().getId());
log.info("Adding disabled exp role {} for server {}.", role.getId(), role.getServer().getId());
return disabledExpRoleRepository.save(newRole);
}

4
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceRoleManagementServiceBean.java
View File

@@ -38,7 +38,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
@Override
public void unsetRole(AExperienceRole role) {
log.info("Deleting experience role {} in server {}.", role.getId(), role.getRoleServer().getId());
log.info("Deleting experience role {} in server {}.", role.getId(), role.getServer().getId());
experienceRoleRepository.delete(role);
}
@@ -93,7 +93,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
.builder()
.id(role.getId())
.level(level)
.roleServer(role.getServer())
.server(role.getServer())
.role(role)
.build();
log.trace("Role did not exist. Creating new.");

2
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/UserExperienceManagementServiceBean.java
View File

@@ -75,7 +75,7 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
@Override
public LeaderBoardEntryResult getRankOfUserInServer(AUserExperience userExperience) {
return repository.getRankOfUserInServer(userExperience.getId(), userExperience.getUser().getServerReference().getId());
return repository.getRankOfUserInServer(userExperience.getId(), userExperience.getServer().getId());
}
@Override

6
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommandTest.java
View File

@@ -75,11 +75,11 @@ public class LeaderBoardCommandTest {
when(userInServerManagementService.loadOrCreateUser(context.getAuthor())).thenReturn(userInAServer);
when(userExperienceService.findLeaderBoardData(server, expectedPage)).thenReturn(leaderBoard);
when(converter.fromLeaderBoard(leaderBoard)).thenReturn(new ArrayList<>());
LeaderBoardEntry executingUserRank = LeaderBoardEntry.builder().build();
LeaderBoardEntry executingUserRank = Mockito.mock(LeaderBoardEntry.class);
when(userExperienceService.getRankOfUserInServer(userInAServer)).thenReturn(executingUserRank);
LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
LeaderBoardEntryModel leaderBoardEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
MessageToSend messageToSend = MessageToSend.builder().build();
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(LeaderBoardCommand.LEADER_BOARD_POST_EMBED_TEMPLATE), any(LeaderBoardModel.class), eq(SERVER_ID))).thenReturn(messageToSend);
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
verify(channelService, times(1)).sendMessageToSendToChannel(messageToSend, context.getChannel());

5
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/ListDisabledExperienceRolesTest.java
View File

@@ -7,7 +7,6 @@ import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
@@ -62,8 +61,8 @@ public class ListDisabledExperienceRolesTest {
public void testCommandExecutionRolesFound() {
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = Mockito.mock(AServer.class);
ADisabledExpRole disabledExpRole1 = ADisabledExpRole.builder().role(MockUtils.getRole(4L, server)).build();
ADisabledExpRole disabledExpRole2 = ADisabledExpRole.builder().role(MockUtils.getRole(6L, server)).build();
ADisabledExpRole disabledExpRole1 = Mockito.mock(ADisabledExpRole.class);
ADisabledExpRole disabledExpRole2 = Mockito.mock(ADisabledExpRole.class);
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(Arrays.asList(disabledExpRole1, disabledExpRole2));
Role role1 = Mockito.mock(Role.class);
Role role2 = Mockito.mock(Role.class);

84
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/converter/LeaderBoardModelConverterTest.java
View File

@@ -1,12 +1,11 @@
package dev.sheldan.abstracto.experience.converter;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.experience.models.LeaderBoard;
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
import net.dv8tion.jda.api.entities.Member;
@@ -34,66 +33,67 @@ public class LeaderBoardModelConverterTest {
@Mock
private MemberService memberService;
private static final Long SERVER_ID = 4L;
private static final Long USER_ID = 5L;
private static final Long USER_ID_2 = 6L;
@Test
public void testFromLeaderBoard() {
AServer server = MockUtils.getServer();
int firstRank = 1;
int firstExperience = 1;
LeaderBoardEntry entry = getEntry(server, firstExperience, firstRank);
int secondRank = 2;
int secondExperience = 2;
LeaderBoardEntry entry2 = getEntry(server, secondExperience, secondRank);
Integer firstRank = 1;
Long firstExperience = 1L;
LeaderBoardEntry entry = getEntry(firstExperience, firstRank, USER_ID);
Integer secondRank = 2;
Long secondExperience = 2L;
LeaderBoardEntry entry2 = getEntry(secondExperience, secondRank, USER_ID_2);
List<LeaderBoardEntry> entries = Arrays.asList(entry, entry2);
LeaderBoard leaderBoard = LeaderBoard.builder().entries(entries).build();
LeaderBoard leaderBoard = Mockito.mock(LeaderBoard.class);
when(leaderBoard.getEntries()).thenReturn(entries);
Member member = Mockito.mock(Member.class);
when(memberService.getMemberInServerAsync(server.getId(), entry.getExperience().getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(server.getId(), entry2.getExperience().getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID_2)).thenReturn(CompletableFuture.completedFuture(member));
List<CompletableFuture<LeaderBoardEntryModel>> leaderBoardEntryModels = testUnit.fromLeaderBoard(leaderBoard);
LeaderBoardEntryModel firstEntry = leaderBoardEntryModels.get(0).join();
Assert.assertEquals(firstRank, firstEntry.getRank().intValue());
Assert.assertEquals(firstExperience, firstEntry.getExperience().getExperience().longValue());
Assert.assertEquals(firstRank, firstEntry.getRank());
Assert.assertEquals(firstExperience, firstEntry.getExperience().getExperience());
LeaderBoardEntryModel secondEntry = leaderBoardEntryModels.get(1).join();
Assert.assertEquals(secondRank, secondEntry.getRank().intValue());
Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience().longValue());
Assert.assertEquals(secondRank, secondEntry.getRank());
Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience());
Assert.assertEquals(entries.size(), leaderBoardEntryModels.size());
}
@Test
public void testFromEntry() {
AServer server = MockUtils.getServer();
Long userId = 3L;
AUserExperience experience = getUserExperienceObject(server, userId);
LeaderBoardEntry entry = LeaderBoardEntry.builder().experience(experience).rank(1).build();
Integer rank = 2;
LeaderBoardEntry entry = getEntry(1L, rank, USER_ID);
Member member = Mockito.mock(Member.class);
User user = Mockito.mock(User.class);
when(user.getIdLong()).thenReturn(userId);
when(user.getIdLong()).thenReturn(USER_ID);
when(member.getUser()).thenReturn(user);
when(memberService.getMemberInServerAsync(server.getId(), experience.getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
CompletableFuture<LeaderBoardEntryModel> leaderBoardEntryModel = testUnit.fromLeaderBoardEntry(entry);
LeaderBoardEntryModel entryModel = leaderBoardEntryModel.join();
Assert.assertEquals(1, entryModel.getRank().intValue());
Assert.assertEquals(experience.getUser().getUserReference().getId(), entryModel.getExperience().getUser().getUserReference().getId());
Assert.assertEquals(experience.getUser().getUserReference().getId().longValue(), entryModel.getMember().getUser().getIdLong());
Assert.assertEquals(rank, entryModel.getRank());
Assert.assertEquals(USER_ID, entryModel.getExperience().getUser().getUserReference().getId());
Assert.assertEquals(USER_ID.longValue(), entryModel.getMember().getUser().getIdLong());
}
private LeaderBoardEntry getEntry(AServer server, Integer experienceParameter, Integer rank) {
AUserExperience firstExperience = getUserExperienceObject(server, experienceParameter);
return LeaderBoardEntry.builder().rank(rank).experience(firstExperience).build();
private LeaderBoardEntry getEntry(Long experienceCount, Integer rank, Long userId) {
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(experience.getExperience()).thenReturn(experienceCount);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(experience.getUser()).thenReturn(userInAServer);
AUser user = Mockito.mock(AUser.class);
when(userInAServer.getUserReference()).thenReturn(user);
when(user.getId()).thenReturn(userId);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(userInAServer.getServerReference()).thenReturn(server);
LeaderBoardEntry entry = Mockito.mock(LeaderBoardEntry.class);
when(entry.getRank()).thenReturn(rank);
when(entry.getExperience()).thenReturn(experience);
return entry;
}
private AUserExperience getUserExperienceObject(AServer server, long i) {
AUserInAServer userObject = MockUtils.getUserObject(i, server);
AExperienceLevel level = AExperienceLevel
.builder()
.level((int)i)
.experienceNeeded(i * 100)
.build();
return AUserExperience
.builder()
.user(userObject)
.experience(i)
.currentLevel(level)
.build();
}
}

10
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBeanTest.java
View File

@@ -7,7 +7,6 @@ import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
import dev.sheldan.abstracto.experience.models.LeaderBoard;
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
@@ -315,6 +314,7 @@ public class AUserExperienceServiceBeanTest {
future.join();
Assert.assertFalse(future.isCompletedExceptionally());
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).removeRoleFromUserFuture(any(AUserInAServer.class), any());
verify(self, times(1)).persistExperienceChanges(anyList());
}
@@ -332,8 +332,8 @@ public class AUserExperienceServiceBeanTest {
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).removeRoleFromUserFuture(any(AUserInAServer.class), any());
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any());
verify(self, times(1)).persistExperienceChanges(anyList());
}
@@ -388,7 +388,9 @@ public class AUserExperienceServiceBeanTest {
setupDefaultConfig();
setupLevelsAndRolesAndNoDisallowed();
setExperienceRoleLevels();
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
CompletableFuture<Void> future = testUnit.handleExperienceGain(Arrays.asList(serverExperience));
future.join();
Assert.assertFalse(future.isCompletedExceptionally());
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
verify(self, times(1)).persistExperienceChanges(anyList());

4
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/ExperienceLevelServiceBeanTest.java
View File

@@ -36,7 +36,9 @@ public class ExperienceLevelServiceBeanTest {
@Test
public void testExperienceToNextLevelCalculation() {
when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.of(AExperienceLevel.builder().level(51).experienceNeeded(15L).build()));
AExperienceLevel level = mock(AExperienceLevel.class);
when(level.getExperienceNeeded()).thenReturn(15L);
when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.of(level));
Long experience = testingUnit.calculateExperienceToNextLevel(50, 10L);
Assert.assertEquals(5L, experience.longValue());
}

81
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/ExperienceRoleServiceBeanTest.java
View File

@@ -1,7 +1,6 @@
package dev.sheldan.abstracto.experience.service;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelType;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
@@ -58,30 +57,30 @@ public class ExperienceRoleServiceBeanTest {
private AServer server;
private static final Long CHANNEL_ID = 4L;
private static final Long ROLE_ID = 5L;
@Test
public void testSettingRoleToLevelWithoutOldUsers() {
Integer levelCount = 10;
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
Role roleToChange = Mockito.mock(Role.class);
ARole role = Mockito.mock(ARole.class);
Long roleId = 5L;
when(roleToChange.getIdLong()).thenReturn(roleId);
when(roleManagementService.findRole(roleId)).thenReturn(role);
AExperienceRole previousExperienceRole = AExperienceRole.builder().role(role).roleServer(server).level(level).build();
when(roleToChange.getIdLong()).thenReturn(ROLE_ID);
when(roleManagementService.findRole(ROLE_ID)).thenReturn(role);
AExperienceRole previousExperienceRole = Mockito.mock(AExperienceRole.class);
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
future.join();
verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
verify(self, times(1)).unsetRoleInDb(levelCount, roleId);
verify(self, times(1)).unsetRoleInDb(levelCount, ROLE_ID);
}
@Test
public void testUnsetRoleInDb() {
Integer levelCount = 10;
AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
ARole roleToChange = getRole(1L, server);
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
ARole roleToChange = Mockito.mock(ARole.class);
when(roleToChange.getServer()).thenReturn(server);
when(experienceLevelService.getLevel(levelCount)).thenReturn(Optional.of(level));
when(roleManagementService.findRole(roleToChange.getId())).thenReturn(roleToChange);
testingUnit.unsetRoleInDb(levelCount, roleToChange.getId());
@@ -95,19 +94,17 @@ public class ExperienceRoleServiceBeanTest {
@Test
public void testSettingRoleToLevelExistingUsers() {
Integer levelCount = 10;
AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
Role roleToChange = Mockito.mock(Role.class);
ARole role = Mockito.mock(ARole.class);
Long roleId = 5L;
when(roleToChange.getIdLong()).thenReturn(roleId);
when(roleManagementService.findRole(roleId)).thenReturn(role);
when(roleToChange.getIdLong()).thenReturn(ROLE_ID);
when(roleManagementService.findRole(ROLE_ID)).thenReturn(role);
when(role.getServer()).thenReturn(server);
ARole newRoleToAward = getRole(2L, server);
AUserExperience firstUser = AUserExperience.builder().build();
AUserExperience secondUser = AUserExperience.builder().build();
AUserExperience firstUser = Mockito.mock(AUserExperience.class);
AUserExperience secondUser = Mockito.mock(AUserExperience.class);
List<AUserExperience> users = Arrays.asList(firstUser, secondUser);
AExperienceRole previousExperienceRole = AExperienceRole.builder().role(role).id(roleToChange.getIdLong()).roleServer(server).level(level).users(users).build();
AExperienceRole newExperienceRole = AExperienceRole.builder().role(newRoleToAward).id(newRoleToAward.getId()).roleServer(server).level(level).build();
AExperienceRole previousExperienceRole = Mockito.mock(AExperienceRole.class);
when(previousExperienceRole.getUsers()).thenReturn(users);
AExperienceRole newExperienceRole = Mockito.mock(AExperienceRole.class);
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(new ArrayList<>(Arrays.asList(newExperienceRole, previousExperienceRole)));
List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
@@ -124,55 +121,55 @@ public class ExperienceRoleServiceBeanTest {
@Test
public void testCalculateRoleForLevelInBetween() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 7);
Assert.assertEquals(5, aExperienceRole.getLevel().getLevel().intValue());
}
@Test
public void testCalculateRoleForLevelBelow() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(4).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 4);
Assert.assertNull(aExperienceRole);
}
@Test
public void testCalculateRoleForLevelOver() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(11).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 11);
Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
}
@Test
public void testCalculateRoleForLevelExact() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(10).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
Integer level = 10;
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, level);
Assert.assertEquals(level, aExperienceRole.getLevel().getLevel());
}
@Test
public void testCalculateRoleForNoRoleConfigFound() {
List<AExperienceRole> roles = new ArrayList<>();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 10);
Assert.assertNull(aExperienceRole);
}
@Test
public void testCalculatingLevelOfNextRole() {
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(getExperienceRoles());
AExperienceLevel levelToCheckFor = AExperienceLevel.builder().level(7).build();
List<AExperienceRole> experienceRoles = getExperienceRoles();
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
AExperienceLevel levelToCheckFor = Mockito.mock(AExperienceLevel.class);
when(levelToCheckFor.getLevel()).thenReturn(7);
AExperienceLevel levelOfNextRole = testingUnit.getLevelOfNextRole(levelToCheckFor, server);
Assert.assertEquals(10, levelOfNextRole.getLevel().intValue());
}
@Test
public void testCalculatingLevelOfNextRoleIfThereIsNone() {
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(getExperienceRoles());
AExperienceLevel levelToCheckFor = AExperienceLevel.builder().level(15).build();
List<AExperienceRole> experienceRoles = getExperienceRoles();
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
AExperienceLevel levelToCheckFor = Mockito.mock(AExperienceLevel.class);
when(levelToCheckFor.getLevel()).thenReturn(15);
AExperienceLevel levelOfNextRole = testingUnit.getLevelOfNextRole(levelToCheckFor, server);
Assert.assertEquals(200, levelOfNextRole.getLevel().intValue());
}
@@ -180,20 +177,16 @@ public class ExperienceRoleServiceBeanTest {
private List<AExperienceRole> getExperienceRoles() {
AExperienceRole level5ExperienceRole = getExperienceRoleForLevel(5);
AExperienceRole level10ExperienceRole = getExperienceRoleForLevel(10);
when(level5ExperienceRole.getServer()).thenReturn(server);
return Arrays.asList(level5ExperienceRole, level10ExperienceRole);
}
private AExperienceRole getExperienceRoleForLevel(int levelToBuild) {
AExperienceLevel firstLevel = AExperienceLevel.builder().level(levelToBuild).build();
return AExperienceRole.builder().roleServer(server).level(firstLevel).build();
}
private ARole getRole(Long id, AServer server) {
return ARole.builder().id(id).server(server).deleted(false).build();
}
private AChannel getFeedbackChannel(AServer server) {
return AChannel.builder().id(1L).server(server).type(AChannelType.TEXT).build();
private AExperienceRole getExperienceRoleForLevel(int level) {
AExperienceLevel experienceLevel = Mockito.mock(AExperienceLevel.class);
when(experienceLevel.getLevel()).thenReturn(level);
AExperienceRole role = Mockito.mock(AExperienceRole.class);
when(role.getLevel()).thenReturn(experienceLevel);
return role;
}
}

26
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/management/DisabledExpRoleManagementServiceBeanTest.java
View File

@@ -9,6 +9,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.*;
@@ -24,17 +25,20 @@ public class DisabledExpRoleManagementServiceBeanTest {
@Test
public void testRoleToSetDisabled() {
ARole role = getARole();
ADisabledExpRole createdDisabledRole = getDisabledRole(role);
ARole role = Mockito.mock(ARole.class);
AServer server = Mockito.mock(AServer.class);
when(role.getServer()).thenReturn(server);
ADisabledExpRole createdDisabledRole = Mockito.mock(ADisabledExpRole.class);
when(createdDisabledRole.getRole()).thenReturn(role);
when(disabledExpRoleRepository.save(any(ADisabledExpRole.class))).thenReturn(createdDisabledRole);
ADisabledExpRole aDisabledExpRole = testUnit.setRoleToBeDisabledForExp(role);
Assert.assertEquals(role.getId(), aDisabledExpRole.getRole().getId());
Assert.assertEquals(createdDisabledRole.getId(), aDisabledExpRole.getId());
Assert.assertEquals(role, aDisabledExpRole.getRole());
Assert.assertEquals(createdDisabledRole, aDisabledExpRole);
}
@Test
public void testIfRoleIsDisabled() {
ARole aRole = getARole();
ARole aRole = Mockito.mock(ARole.class);
when(disabledExpRoleRepository.existsByRole(aRole)).thenReturn(true);
boolean experienceDisabledForRole = testUnit.isExperienceDisabledForRole(aRole);
Assert.assertTrue(experienceDisabledForRole);
@@ -43,24 +47,16 @@ public class DisabledExpRoleManagementServiceBeanTest {
@Test
public void testRemoveRoleFromDisabled() {
ARole aRole = getARole();
ARole aRole = Mockito.mock(ARole.class);
testUnit.removeRoleToBeDisabledForExp(aRole);
verify(disabledExpRoleRepository, times(1)).deleteByRole(aRole);
}
@Test
public void testRetrieveAllDisabledRolesForServer() {
AServer server = AServer.builder().id(1L).build();
AServer server = Mockito.mock(AServer.class);
testUnit.getDisabledRolesForServer(server);
verify(disabledExpRoleRepository, times(1)).getByRole_Server(server);
}
private ADisabledExpRole getDisabledRole(ARole role) {
return ADisabledExpRole.builder().role(role).id(2L).build();
}
private ARole getARole() {
AServer server = AServer.builder().id(4L).build();
return ARole.builder().id(1L).server(server).build();
}
}

26
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/management/ExperienceLevelManagementServiceBeanTest.java
View File

@@ -7,6 +7,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -29,7 +30,9 @@ public class ExperienceLevelManagementServiceBeanTest {
public void testCreateExperienceLevel() {
Integer level = 1;
Long neededExperience = 100L;
AExperienceLevel createdLevel = getLevel(level, neededExperience);
AExperienceLevel createdLevel = Mockito.mock(AExperienceLevel.class);
when(createdLevel.getLevel()).thenReturn(level);
when(createdLevel.getExperienceNeeded()).thenReturn(neededExperience);
when(experienceLevelRepository.save(any(AExperienceLevel.class))).thenReturn(createdLevel);
AExperienceLevel experienceLevel = testUnit.createExperienceLevel(level, neededExperience);
Assert.assertEquals(experienceLevel.getLevel(), createdLevel.getLevel());
@@ -47,8 +50,10 @@ public class ExperienceLevelManagementServiceBeanTest {
public void testFindLevel() {
int levelValue = 1;
long experienceAmount = 100L;
Optional<AExperienceLevel> level = Optional.of(getLevel(levelValue, experienceAmount));
when(experienceLevelRepository.findById(levelValue)).thenReturn(level);
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
when(level.getLevel()).thenReturn(levelValue);
when(level.getExperienceNeeded()).thenReturn(experienceAmount);
when(experienceLevelRepository.findById(levelValue)).thenReturn(Optional.of(level));
Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevel(levelValue);
Assert.assertTrue(foundLevelOptional.isPresent());
if(foundLevelOptional.isPresent()) {
@@ -71,8 +76,12 @@ public class ExperienceLevelManagementServiceBeanTest {
@Test
public void findAllLevelConfigurations() {
AExperienceLevel availableLevel = getLevel(1, 100L);
AExperienceLevel availableLevel2 = getLevel(2, 200L);
AExperienceLevel availableLevel = Mockito.mock(AExperienceLevel.class);
when(availableLevel.getLevel()).thenReturn(1);
when(availableLevel.getExperienceNeeded()).thenReturn(100L);
AExperienceLevel availableLevel2 = Mockito.mock(AExperienceLevel.class);
when(availableLevel2.getLevel()).thenReturn(2);
when(availableLevel2.getExperienceNeeded()).thenReturn(200L);
List<AExperienceLevel> levelConfig = Arrays.asList(availableLevel, availableLevel2);
when(experienceLevelRepository.findAll()).thenReturn(levelConfig);
List<AExperienceLevel> foundLevelConfig = testUnit.getLevelConfig();
@@ -84,11 +93,4 @@ public class ExperienceLevelManagementServiceBeanTest {
Assert.assertEquals(2, secondLevelConfig.getLevel().intValue());
}
private AExperienceLevel getLevel(Integer level, Long neededExperience) {
return AExperienceLevel
.builder()
.level(level)
.experienceNeeded(neededExperience)
.build();
}
}

118
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/management/ExperienceRoleManagementServiceBeanTest.java
View File

@@ -2,17 +2,13 @@ package dev.sheldan.abstracto.experience.service.management;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
import dev.sheldan.abstracto.experience.repository.ExperienceRoleRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
@@ -35,29 +31,39 @@ public class ExperienceRoleManagementServiceBeanTest {
@Captor
private ArgumentCaptor<AExperienceRole> roleArgumentCaptor;
@Mock
private AExperienceRole experienceRole;
@Mock
private ARole role;
@Mock
private AServer server;
@Mock
private AExperienceLevel level;
private static final Long SERVER_ID = 3L;
private static final Long ROLE_ID = 4L;
@Test
public void testRemovingAllRoleAssignmentsForLevel() {
AServer server = MockUtils.getServer();
AExperienceLevel level = getLevel(10, 100L);
List<AExperienceRole> experienceRoles = getExperienceRoles();
when(level.getLevel()).thenReturn(10);
AExperienceRole secondRole = Mockito.mock(AExperienceRole.class);
List<AExperienceRole> experienceRoles = Arrays.asList(experienceRole, secondRole);
when(experienceRoleRepository.findByLevelAndRoleServer(level, server)).thenReturn(experienceRoles);
testUnit.removeAllRoleAssignmentsForLevelInServer(level, server);
verify(experienceRoleRepository, times(1)).findByLevelAndRoleServer(level, server);
verify(experienceRoleRepository, times(experienceRoles.size())).delete(roleArgumentCaptor.capture());
List<AExperienceRole> allValues = roleArgumentCaptor.getAllValues();
for (int i = 0; i < allValues.size(); i++) {
AExperienceRole role = allValues.get(i);
AExperienceRole innerRole = experienceRoles.get(i);
Assert.assertEquals(innerRole.getLevel().getLevel(), role.getLevel().getLevel());
Assert.assertEquals(innerRole.getRole().getId(), role.getRole().getId());
}
Assert.assertEquals(experienceRole, allValues.get(0));
Assert.assertEquals(secondRole, allValues.get(1));
Assert.assertEquals(2, allValues.size());
}
@Test
public void removeRoleAssignmentsForLevelWithoutAny() {
AServer server = MockUtils.getServer();
AExperienceLevel level = getLevel(10, 100L);
when(level.getLevel()).thenReturn(10);
List<AExperienceRole> experienceRoles = new ArrayList<>();
when(experienceRoleRepository.findByLevelAndRoleServer(level, server)).thenReturn(experienceRoles);
testUnit.removeAllRoleAssignmentsForLevelInServer(level, server);
@@ -69,79 +75,61 @@ public class ExperienceRoleManagementServiceBeanTest {
@Test
public void testUnsetRole() {
AExperienceRole role = getExperienceRoleForLevel(37);
testUnit.unsetRole(role);
verify(experienceRoleRepository, times(1)).delete(role);
when(experienceRole.getServer()).thenReturn(server);
testUnit.unsetRole(experienceRole);
verify(experienceRoleRepository, times(1)).delete(experienceRole);
}
@Test
public void testFindExperienceRoleForRoleInServer() {
AExperienceRole expRole = getExperienceRoleForLevel(37);
when((experienceRoleRepository.findByRole(expRole.getRole()))).thenReturn(Optional.of(expRole));
AExperienceRole roleInServer = testUnit.getRoleInServer(expRole.getRole());
Assert.assertEquals(expRole.getRole().getId(), roleInServer.getRole().getId());
verify(experienceRoleRepository, times(1)).findByRole(expRole.getRole());
when((experienceRoleRepository.findByRole(role))).thenReturn(Optional.of(experienceRole));
AExperienceRole roleInServer = testUnit.getRoleInServer(role);
Assert.assertEquals(experienceRole, roleInServer);
}
@Test
public void testFindExperienceRolesForServer() {
AServer server = MockUtils.getServer();
List<AExperienceRole> experienceRoles = getExperienceRoles();
AExperienceRole secondRole = Mockito.mock(AExperienceRole.class);
List<AExperienceRole> experienceRoles = Arrays.asList(experienceRole, secondRole);
when(experienceRoleRepository.findByRoleServer(server)).thenReturn(experienceRoles);
List<AExperienceRole> experienceRolesForServer = testUnit.getExperienceRolesForServer(server);
verify(experienceRoleRepository, times(1)).findByRoleServer(server);
for (int i = 0; i < experienceRolesForServer.size(); i++) {
AExperienceRole role = experienceRolesForServer.get(i);
AExperienceRole innerRole = experienceRoles.get(i);
Assert.assertEquals(innerRole.getLevel().getLevel(), role.getLevel().getLevel());
Assert.assertEquals(innerRole.getRole().getId(), role.getRole().getId());
}
Assert.assertEquals(experienceRole, experienceRolesForServer.get(0));
Assert.assertEquals(secondRole, experienceRolesForServer.get(1));
Assert.assertEquals(2, experienceRolesForServer.size());
}
@Test
public void setLevelToRoleWhichHasAnExistingMapping() {
int level = 5;
AExperienceRole experienceRole = getExperienceRoleForLevel(level);
when(experienceRoleRepository.findByRole(experienceRole.getRole())).thenReturn(Optional.of(experienceRole));
AExperienceLevel newLevel = AExperienceLevel.builder().level(8).build();
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, experienceRole.getRole());
verify(experienceRoleRepository, times(1)).findByRole(experienceRole.getRole());
Assert.assertEquals(newLevel.getLevel(), updatedExperienceRole.getLevel().getLevel());
Integer levelNumber = 4;
setupExperienceRole(levelNumber);
when(experienceRoleRepository.findByRole(role)).thenReturn(Optional.of(experienceRole));
AExperienceLevel newLevel = Mockito.mock(AExperienceLevel.class);
when(newLevel.getLevel()).thenReturn(levelNumber);
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, role);
verify(experienceRoleRepository, times(1)).findByRole(role);
Assert.assertEquals(levelNumber, updatedExperienceRole.getLevel().getLevel());
}
@Test
public void setLevelToRoleWithoutAMappingExistingPreviously() {
int level = 5;
AExperienceRole experienceRole = getExperienceRoleForLevel(level);
Integer levelNumber = 4;
setupExperienceRole(levelNumber);
when(experienceRoleRepository.findByRole(experienceRole.getRole())).thenReturn(Optional.empty());
when(experienceRoleRepository.save(any(AExperienceRole.class))).thenReturn(experienceRole);
AExperienceLevel newLevel = AExperienceLevel.builder().level(8).build();
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, experienceRole.getRole());
verify(experienceRoleRepository, times(1)).findByRole(experienceRole.getRole());
Assert.assertEquals(experienceRole.getLevel().getLevel(), updatedExperienceRole.getLevel().getLevel());
AExperienceLevel newLevel = Mockito.mock(AExperienceLevel.class);
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, role);
verify(experienceRoleRepository, times(1)).findByRole(role);
Assert.assertEquals(levelNumber, updatedExperienceRole.getLevel().getLevel());
}
private List<AExperienceRole> getExperienceRoles() {
AExperienceRole level5ExperienceRole = getExperienceRoleForLevel(7);
AExperienceRole level10ExperienceRole = getExperienceRoleForLevel(25);
return Arrays.asList(level5ExperienceRole, level10ExperienceRole);
}
private AExperienceRole getExperienceRoleForLevel(int levelToBuild) {
AExperienceLevel firstLevel = AExperienceLevel.builder().level(levelToBuild).build();
AServer server = AServer.builder().id(4L).build();
ARole aRole = ARole.builder().id((long) levelToBuild).server(server).build();
return AExperienceRole.builder().role(aRole).roleServer(server).level(firstLevel).build();
}
private AExperienceLevel getLevel(Integer level, Long neededExperience) {
return AExperienceLevel
.builder()
.level(level)
.experienceNeeded(neededExperience)
.build();
private void setupExperienceRole(Integer levelNumber) {
when(role.getId()).thenReturn(ROLE_ID);
when(server.getId()).thenReturn(SERVER_ID);
when(role.getServer()).thenReturn(server);
when(experienceRole.getRole()).thenReturn(role);
when(level.getLevel()).thenReturn(levelNumber);
when(experienceRole.getLevel()).thenReturn(level);
}
}

92
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/management/UserExperienceManagementServiceBeanTest.java
View File

@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.service.management;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
@@ -35,13 +34,19 @@ public class UserExperienceManagementServiceBeanTest {
@Mock
private ExperienceLevelManagementService experienceLevelManagementService;
private static final Long SERVER_ID = 2L;
private static final Long USER_IN_SERVER_ID = 3L;
private static final Long USER_ID = 4L;
private static final Integer START_LEVEL = 0;
@Test
public void testFindUserInServer() {
AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
AUserExperience experience = AUserExperience.builder().user(user).experience(2L).build();
when(repository.findById(user.getUserInServerId())).thenReturn(Optional.of(experience));
AUserExperience userInServer = testUnit.findUserInServer(user);
Assert.assertEquals(experience.getExperience(), userInServer.getExperience());
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(user.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(repository.findById(USER_IN_SERVER_ID)).thenReturn(Optional.of(experience));
AUserExperience retrievedExperience = testUnit.findUserInServer(user);
Assert.assertEquals(experience, retrievedExperience);
}
@Test
@@ -49,17 +54,20 @@ public class UserExperienceManagementServiceBeanTest {
AUserInAServer user = Mockito.mock(AUserInAServer.class);
AServer server = Mockito.mock(AServer.class);
when(user.getServerReference()).thenReturn(server);
when(server.getId()).thenReturn(2L);
when(server.getId()).thenReturn(SERVER_ID);
AUser aUser = Mockito.mock(AUser.class);
when(aUser.getId()).thenReturn(4L);
when(user.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
when(aUser.getId()).thenReturn(USER_ID);
when(user.getUserReference()).thenReturn(aUser);
when(repository.findById(user.getUserInServerId())).thenReturn(Optional.empty());
AExperienceLevel startLevel = mockInitialLevel();
when(repository.findById(USER_IN_SERVER_ID)).thenReturn(Optional.empty());
AExperienceLevel startLevel = Mockito.mock(AExperienceLevel.class);
when(startLevel.getLevel()).thenReturn(START_LEVEL);
when(experienceLevelManagementService.getLevel(START_LEVEL)).thenReturn(Optional.of(startLevel));
AUserExperience userInServer = testUnit.findUserInServer(user);
Assert.assertEquals(0L, userInServer.getExperience().longValue());
Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
Assert.assertFalse(userInServer.getExperienceGainDisabled());
Assert.assertEquals(startLevel.getLevel(), userInServer.getCurrentLevel().getLevel());
Assert.assertEquals(START_LEVEL, userInServer.getCurrentLevel().getLevel());
}
@Test
@@ -67,76 +75,70 @@ public class UserExperienceManagementServiceBeanTest {
AUserInAServer user = Mockito.mock(AUserInAServer.class);
AServer server = Mockito.mock(AServer.class);
when(user.getServerReference()).thenReturn(server);
when(server.getId()).thenReturn(2L);
when(server.getId()).thenReturn(SERVER_ID);
AUser aUser = Mockito.mock(AUser.class);
when(aUser.getId()).thenReturn(4L);
when(aUser.getId()).thenReturn(USER_ID);
when(user.getUserReference()).thenReturn(aUser);
AExperienceLevel startLevel = mockInitialLevel();
AExperienceLevel startLevel = Mockito.mock(AExperienceLevel.class);
when(startLevel.getLevel()).thenReturn(START_LEVEL);
when(experienceLevelManagementService.getLevel(START_LEVEL)).thenReturn(Optional.of(startLevel));
AUserExperience userInServer = testUnit.createUserInServer(user);
Assert.assertEquals(0L, userInServer.getExperience().longValue());
Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
Assert.assertFalse(userInServer.getExperienceGainDisabled());
Assert.assertEquals(startLevel.getLevel(), userInServer.getCurrentLevel().getLevel());
Assert.assertEquals(START_LEVEL, userInServer.getCurrentLevel().getLevel());
}
@Test
public void testLoadAllUsers() {
AServer server = MockUtils.getServer();
List<AUserExperience> experiences = getUserExperiences();
AServer server = Mockito.mock(AServer.class);
AUserExperience experience = Mockito.mock(AUserExperience.class);
AUserExperience experience2 = Mockito.mock(AUserExperience.class);
List<AUserExperience> experiences = Arrays.asList(experience, experience2);
when(repository.findByUser_ServerReference(server)).thenReturn(experiences);
List<AUserExperience> loadedExperiences = testUnit.loadAllUsers(server);
Assert.assertEquals(experiences.size(), loadedExperiences.size());
Assert.assertEquals(experiences.get(0).getExperience(), loadedExperiences.get(0).getExperience());
Assert.assertEquals(experiences.get(1).getExperience(), loadedExperiences.get(1).getExperience());
Assert.assertEquals(experience, loadedExperiences.get(0));
Assert.assertEquals(experience2, loadedExperiences.get(1));
}
@Test
public void testLoadPaginated() {
AServer server = MockUtils.getServer();
AServer server = Mockito.mock(AServer.class);
int endIndex = 20;
int startIndex = 11;
List<AUserExperience> userExperiences = getUserExperiences();
when(repository.findTop10ByUser_ServerReferenceOrderByExperienceDesc(server, PageRequest.of(startIndex, endIndex))).thenReturn(userExperiences);
AUserExperience experience = Mockito.mock(AUserExperience.class);
AUserExperience experience2 = Mockito.mock(AUserExperience.class);
List<AUserExperience> experiences = Arrays.asList(experience, experience2);
when(repository.findTop10ByUser_ServerReferenceOrderByExperienceDesc(server, PageRequest.of(startIndex, endIndex))).thenReturn(experiences);
List<AUserExperience> leaderBoardUsersPaginated = testUnit.findLeaderBoardUsersPaginated(server, startIndex, endIndex);
Assert.assertEquals(userExperiences.size(), leaderBoardUsersPaginated.size());
for (int i = 0; i < userExperiences.size(); i++) {
Assert.assertEquals(userExperiences.get(i).getExperience(), leaderBoardUsersPaginated.get(i).getExperience());
}
Assert.assertEquals(experiences.size(), leaderBoardUsersPaginated.size());
Assert.assertEquals(experience, leaderBoardUsersPaginated.get(0));
Assert.assertEquals(experience2, leaderBoardUsersPaginated.get(1));
}
@Test
public void testLoadRankOfUser() {
long experienceValue = 2L;
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(6L, server);
AUserExperience experience = AUserExperience.builder().experience(experienceValue).user(user).id(3L).build();
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(experience.getServer()).thenReturn(server);
when(experience.getId()).thenReturn(USER_IN_SERVER_ID);
LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
when(leaderBoardEntryTest.getExperience()).thenReturn(experienceValue);
when(repository.getRankOfUserInServer(experience.getId(), server.getId())).thenReturn(leaderBoardEntryTest);
when(repository.getRankOfUserInServer(USER_IN_SERVER_ID, SERVER_ID)).thenReturn(leaderBoardEntryTest);
LeaderBoardEntryResult rankOfUserInServer = testUnit.getRankOfUserInServer(experience);
Assert.assertEquals(experienceValue, rankOfUserInServer.getExperience().longValue());
}
@Test
public void testSaveUser() {
AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
AUserExperience experience = AUserExperience.builder().user(user).experience(2L).build();
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(repository.save(experience)).thenReturn(experience);
AUserExperience createdInstance = testUnit.saveUser(experience);
Assert.assertEquals(experience.getExperience(), createdInstance.getExperience());
Assert.assertEquals(experience.getUser().getUserReference().getId(), createdInstance.getUser().getUserReference().getId());
Assert.assertEquals(experience, createdInstance);
}
private AExperienceLevel mockInitialLevel() {
AExperienceLevel startLevel = AExperienceLevel.builder().level(0).experienceNeeded(0L).build();
when(experienceLevelManagementService.getLevel(startLevel.getLevel())).thenReturn(Optional.of(startLevel));
return startLevel;
}
private List<AUserExperience> getUserExperiences() {
AUserExperience experience = AUserExperience.builder().experience(2L).build();
AUserExperience experience2 = AUserExperience.builder().experience(2L).build();
return Arrays.asList(experience, experience2);
}
}

2
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/models/database/AExperienceRole.java
View File

@@ -49,7 +49,7 @@ public class AExperienceRole implements Serializable {
@Getter
@Setter
@JoinColumn(name = "server_id", nullable = false)
private AServer roleServer;
private AServer server;
@Column(name = "created")
private Instant created;