mirror of
https://github.com/Sheldan/abstracto.git
synced 2026-04-14 11:48:16 +00:00
[AB-139] changing the places at which there might be an uncached member object
fixing integer validator fixing syncing roles not working if the role did not change in the database fixing warn id being flipped fixing star stats model
This commit is contained in:
Sheldan
@@ -16,6 +16,7 @@ import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
|
||||
import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoard;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
|
||||
import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
|
||||
import dev.sheldan.abstracto.experience.models.templates.LeaderBoardModel;
|
||||
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
|
||||
import dev.sheldan.abstracto.templating.model.MessageToSend;
|
||||
@@ -28,6 +29,7 @@ import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* Shows the experience gain information of the top 10 users in the server, or if a page number is provided as a parameter, only the members which are on this page.
|
||||
@@ -57,15 +59,22 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
|
||||
// parameter is optional, in case its not present, we default to the 0th page
|
||||
Integer page = !parameters.isEmpty() ? (Integer) parameters.get(0) : 1;
|
||||
LeaderBoard leaderBoard = userExperienceService.findLeaderBoardData(commandContext.getUserInitiatedContext().getServer(), page);
|
||||
LeaderBoardModel leaderBoardModel = (LeaderBoardModel) ContextConverter.fromCommandContext(commandContext, LeaderBoardModel.class);
|
||||
leaderBoardModel.setUserExperiences(converter.fromLeaderBoard(leaderBoard));
|
||||
LeaderBoardModel leaderBoardModel = (LeaderBoardModel) ContextConverter.slimFromCommandContext(commandContext, LeaderBoardModel.class);
|
||||
List<CompletableFuture<LeaderBoardEntryModel>> futures = new ArrayList<>();
|
||||
List<CompletableFuture<LeaderBoardEntryModel>> completableFutures = converter.fromLeaderBoard(leaderBoard);
|
||||
futures.addAll(completableFutures);
|
||||
log.info("Rendering leaderboard for page {} in server {} for user {}.", page, commandContext.getAuthor().getId(), commandContext.getGuild().getId());
|
||||
|
||||
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
|
||||
leaderBoardModel.setUserExecuting(converter.fromLeaderBoardEntry(userRank));
|
||||
MessageToSend messageToSend = templateService.renderEmbedTemplate(LEADER_BOARD_POST_EMBED_TEMPLATE, leaderBoardModel);
|
||||
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
|
||||
.thenApply(aVoid -> CommandResult.fromSuccess());
|
||||
CompletableFuture<LeaderBoardEntryModel> userRankFuture = converter.fromLeaderBoardEntry(userRank);
|
||||
futures.add(userRankFuture);
|
||||
return FutureUtils.toSingleFutureGeneric(futures).thenCompose(aVoid -> {
|
||||
List<LeaderBoardEntryModel> finalModels = completableFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
|
||||
leaderBoardModel.setUserExperiences(finalModels);
|
||||
leaderBoardModel.setUserExecuting(userRankFuture.join());
|
||||
MessageToSend messageToSend = templateService.renderEmbedTemplate(LEADER_BOARD_POST_EMBED_TEMPLATE, leaderBoardModel);
|
||||
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()));
|
||||
}).thenApply(aVoid -> CommandResult.fromSuccess());
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -8,20 +8,25 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.service.ChannelService;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.core.utils.FutureUtils;
|
||||
import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
|
||||
import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
|
||||
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
|
||||
import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
|
||||
import dev.sheldan.abstracto.experience.models.templates.RankModel;
|
||||
import dev.sheldan.abstracto.experience.service.ExperienceLevelService;
|
||||
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
|
||||
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
|
||||
import dev.sheldan.abstracto.templating.model.MessageToSend;
|
||||
import dev.sheldan.abstracto.templating.service.TemplateService;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@@ -50,19 +55,35 @@ public class Rank extends AbstractConditionableCommand {
|
||||
@Autowired
|
||||
private ChannelService channelService;
|
||||
|
||||
@Autowired
|
||||
private Rank self;
|
||||
|
||||
@Autowired
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
|
||||
@Autowired
|
||||
private UserExperienceManagementService userExperienceManagementService;
|
||||
|
||||
@Override
|
||||
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
|
||||
checkParameters(commandContext);
|
||||
RankModel rankModel = (RankModel) ContextConverter.fromCommandContext(commandContext, RankModel.class);
|
||||
RankModel rankModel = (RankModel) ContextConverter.slimFromCommandContext(commandContext, RankModel.class);
|
||||
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
|
||||
rankModel.setRankUser(converter.fromLeaderBoardEntry(userRank));
|
||||
AUserExperience experienceObj = userRank.getExperience();
|
||||
CompletableFuture<LeaderBoardEntryModel> future = converter.fromLeaderBoardEntry(userRank);
|
||||
return future.thenCompose(leaderBoardEntryModel ->
|
||||
self.renderAndSendRank(commandContext, rankModel, leaderBoardEntryModel)
|
||||
).thenApply(result -> CommandResult.fromSuccess());
|
||||
}
|
||||
|
||||
@Transactional
|
||||
public CompletableFuture<Void> renderAndSendRank(CommandContext commandContext, RankModel rankModel, LeaderBoardEntryModel leaderBoardEntryModel) {
|
||||
rankModel.setRankUser(leaderBoardEntryModel);
|
||||
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
|
||||
AUserExperience experienceObj = userExperienceManagementService.findUserInServer(aUserInAServer);
|
||||
log.info("Rendering rank for user {} in server {}.", commandContext.getAuthor().getId(), commandContext.getGuild().getId());
|
||||
rankModel.setExperienceToNextLevel(experienceLevelService.calculateExperienceToNextLevel(experienceObj.getCurrentLevel().getLevel(), experienceObj.getExperience()));
|
||||
MessageToSend messageToSend = templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel);
|
||||
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
|
||||
.thenApply(aVoid -> CommandResult.fromSuccess());
|
||||
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -12,6 +12,7 @@ import org.springframework.stereotype.Component;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
/**
|
||||
* Converter used to convert from {@link LeaderBoard} to a list of {@link LeaderBoardEntryModel}
|
||||
@@ -30,11 +31,11 @@ public class LeaderBoardModelConverter {
|
||||
* @return The list of {@link LeaderBoardEntryModel} which contain the fully fledged information provided to the
|
||||
* leader board template
|
||||
*/
|
||||
public List<LeaderBoardEntryModel> fromLeaderBoard(LeaderBoard leaderBoard) {
|
||||
List<LeaderBoardEntryModel> models = new ArrayList<>();
|
||||
public List<CompletableFuture<LeaderBoardEntryModel>> fromLeaderBoard(LeaderBoard leaderBoard) {
|
||||
List<CompletableFuture<LeaderBoardEntryModel>> models = new ArrayList<>();
|
||||
log.trace("Converting {} entries to a list of leaderbord entries.", leaderBoard.getEntries().size());
|
||||
leaderBoard.getEntries().forEach(leaderBoardEntry -> {
|
||||
LeaderBoardEntryModel entry = fromLeaderBoardEntry(leaderBoardEntry);
|
||||
CompletableFuture<LeaderBoardEntryModel> entry = fromLeaderBoardEntry(leaderBoardEntry);
|
||||
models.add(entry);
|
||||
});
|
||||
return models;
|
||||
@@ -47,14 +48,15 @@ public class LeaderBoardModelConverter {
|
||||
* @return The {@link LeaderBoardEntryModel} accompanied with the {@link Member} reference, might be null, if the
|
||||
* user left the guild
|
||||
*/
|
||||
public LeaderBoardEntryModel fromLeaderBoardEntry(LeaderBoardEntry leaderBoardEntry) {
|
||||
public CompletableFuture<LeaderBoardEntryModel> fromLeaderBoardEntry(LeaderBoardEntry leaderBoardEntry) {
|
||||
AUserInAServer entryUser = leaderBoardEntry.getExperience().getUser();
|
||||
Member entryMember = botService.getMemberInServer(entryUser.getServerReference().getId(), entryUser.getUserReference().getId());
|
||||
return LeaderBoardEntryModel
|
||||
.builder()
|
||||
.experience(leaderBoardEntry.getExperience())
|
||||
.member(entryMember).rank(leaderBoardEntry.getRank())
|
||||
.rank(leaderBoardEntry.getRank())
|
||||
.build();
|
||||
return botService.getMemberInServerAsync(entryUser.getServerReference().getId(), entryUser.getUserReference().getId()).thenApply(member ->
|
||||
LeaderBoardEntryModel
|
||||
.builder()
|
||||
.experience(leaderBoardEntry.getExperience())
|
||||
.member(member).rank(leaderBoardEntry.getRank())
|
||||
.rank(leaderBoardEntry.getRank())
|
||||
.build()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -186,7 +186,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
AUserInAServer userInAServer = userInServerManagementService.loadUser(userInAServerId);
|
||||
gainedExperience = (int) Math.floor(gainedExperience * multiplier);
|
||||
Member member = botService.getMemberInServer(userInAServer);
|
||||
if(!roleService.hasAnyOfTheRoles(member, disabledRoles)) {
|
||||
if(member != null && !roleService.hasAnyOfTheRoles(member, disabledRoles)) {
|
||||
log.trace("Handling {}. The user gains {}", userInAServer.getUserReference().getId(), gainedExperience);
|
||||
Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServerId);
|
||||
if(aUserExperienceOptional.isPresent()) {
|
||||
@@ -230,7 +230,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
futures.add(resultFuture);
|
||||
}
|
||||
} else {
|
||||
log.trace("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
|
||||
log.trace("User {} has a role which makes the user unable to gain experience or the member could not be found in the server.", userInAServer.getUserInServerId());
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -321,43 +321,62 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
.userInServerId(user.getUserInServerId())
|
||||
.experienceRoleId(null)
|
||||
.build();
|
||||
if(!botService.isUserInGuild(userExperience.getUser())) {
|
||||
log.trace("User {} is not in server {} anymore. No role calculation done.", userExperience.getUser().getUserInServerId(), userExperience.getUser().getServerReference().getId());
|
||||
return CompletableFuture.completedFuture(returnNullRole.apply(null));
|
||||
}
|
||||
Long userInServerId = user.getUserInServerId();
|
||||
log.trace("Updating experience role for user {} in server {}", user.getUserReference().getId(), user.getServerReference().getId());
|
||||
Long serverId = user.getServerReference().getId();
|
||||
log.trace("Updating experience role for user {} in server {}", user.getUserReference().getId(), serverId);
|
||||
AExperienceRole role = experienceRoleService.calculateRole(roles, currentLevel);
|
||||
Member member = botService.getMemberInServer(user.getServerReference(), user.getUserReference());
|
||||
boolean currentlyHasNoExperienceRole = userExperience.getCurrentExperienceRole() == null;
|
||||
// if calculation results in no role, do not add a role
|
||||
if(role == null) {
|
||||
log.trace("User {} in server {} does not have an experience role, according to new calculation.",
|
||||
user.getUserReference().getId(), user.getServerReference().getId());
|
||||
user.getUserReference().getId(), serverId);
|
||||
// if the user has a experience role currently, remove it
|
||||
if(!currentlyHasNoExperienceRole){
|
||||
return roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole())
|
||||
.thenApply(returnNullRole);
|
||||
}
|
||||
return CompletableFuture.completedFuture(returnNullRole.apply(null));
|
||||
}
|
||||
boolean userHasRoleAlready = roleService.memberHasRole(member, role.getRole());
|
||||
Long experienceRoleId = role.getId();
|
||||
Function<Void, RoleCalculationResult> fullResult = aVoid -> RoleCalculationResult
|
||||
.builder()
|
||||
.experienceRoleId(experienceRoleId)
|
||||
.userInServerId(userInServerId)
|
||||
.build();
|
||||
if(!userHasRoleAlready && (currentlyHasNoExperienceRole || !role.getRole().getId().equals(userExperience.getCurrentExperienceRole().getRole().getId()))) {
|
||||
log.info("User {} in server {} gets a new role {} because of experience.", user.getUserReference().getId(), user.getServerReference().getId(), role.getRole().getId());
|
||||
CompletableFuture<Void> removalFuture;
|
||||
if(!currentlyHasNoExperienceRole && botService.isUserInGuild(userExperience.getUser())) {
|
||||
removalFuture = roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole());
|
||||
} else {
|
||||
removalFuture = CompletableFuture.completedFuture(null);
|
||||
Long roleId = role.getRole().getId();
|
||||
// if the new role is already the one configured in the database
|
||||
Long userId = user.getUserReference().getId();
|
||||
Long oldUserExperienceRoleId = currentlyHasNoExperienceRole ? 0L : userExperience.getCurrentExperienceRole().getRole().getId();
|
||||
return botService.getMemberInServerAsync(user).thenCompose(member -> {
|
||||
boolean userHasRoleAlready = roleService.memberHasRole(member, roleId);
|
||||
boolean userHasOldRole = false;
|
||||
boolean rolesChanged = true;
|
||||
if(!currentlyHasNoExperienceRole) {
|
||||
userHasOldRole = roleService.memberHasRole(member, oldUserExperienceRoleId);
|
||||
rolesChanged = !roleId.equals(oldUserExperienceRoleId);
|
||||
}
|
||||
CompletableFuture<Void> addRoleFuture = roleService.addRoleToUserFuture(user, role.getRole());
|
||||
return CompletableFuture.allOf(removalFuture, addRoleFuture).thenApply(fullResult);
|
||||
}
|
||||
return CompletableFuture.completedFuture(fullResult.apply(null));
|
||||
Function<Void, RoleCalculationResult> fullResult = aVoid -> RoleCalculationResult
|
||||
.builder()
|
||||
.experienceRoleId(experienceRoleId)
|
||||
.userInServerId(userInServerId)
|
||||
.build();
|
||||
// if the roles changed or
|
||||
// the user does not have the new target role already
|
||||
// the user still has the old role
|
||||
if((!userHasRoleAlready || userHasOldRole)) {
|
||||
log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
|
||||
CompletableFuture<Void> removalFuture;
|
||||
if(userHasOldRole && rolesChanged) {
|
||||
removalFuture = roleService.removeRoleFromMemberAsync(member, oldUserExperienceRoleId);
|
||||
} else {
|
||||
removalFuture = CompletableFuture.completedFuture(null);
|
||||
}
|
||||
CompletableFuture<Void> addRoleFuture;
|
||||
if(!userHasRoleAlready) {
|
||||
addRoleFuture = roleService.addRoleToMemberFuture(member, roleId);
|
||||
} else {
|
||||
addRoleFuture = CompletableFuture.completedFuture(null);
|
||||
}
|
||||
return CompletableFuture.allOf(removalFuture, addRoleFuture).thenApply(fullResult);
|
||||
}
|
||||
// we are turning the full calculation result regardless
|
||||
return CompletableFuture.completedFuture(fullResult.apply(null));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -405,7 +424,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
if(result != null) {
|
||||
AUserInAServer user = userInServerManagementService.loadUser(result.getUserInServerId());
|
||||
AUserExperience userExperience = userExperienceManagementService.findUserInServer(user);
|
||||
log.trace("Updating experience role for {} in server {} to {}", user.getUserInServerId(), user.getServerReference(), result.getExperienceRoleId());
|
||||
log.trace("Updating experience role for {} in server {} to {}", user.getUserInServerId(), user.getServerReference().getId(), result.getExperienceRoleId());
|
||||
if(result.getExperienceRoleId() != null) {
|
||||
log.trace("User experience {} gets new experience role with id {}.", userExperience.getId(), result.getExperienceRoleId());
|
||||
AExperienceRole role = experienceRoleManagementService.getExperienceRoleById(result.getExperienceRoleId());
|
||||
|
||||
@@ -83,7 +83,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
|
||||
public AExperienceRole setLevelToRole(AExperienceLevel level, ARole role) {
|
||||
Optional<AExperienceRole> byRoleServerAndRoleOptional = getRoleInServerOptional(role);
|
||||
AExperienceRole experienceRole;
|
||||
log.info("Setting role {} in server {} to level {}.", role.getId(), role.getServer().getId(), level);
|
||||
log.info("Setting role {} in server {} to level {}.", role.getId(), role.getServer().getId(), level.getLevel());
|
||||
if(byRoleServerAndRoleOptional.isPresent()) {
|
||||
log.trace("Role already existed. Updating.");
|
||||
experienceRole = byRoleServerAndRoleOptional.get();
|
||||
|
||||
@@ -66,7 +66,7 @@ public class LeaderBoardCommandTest {
|
||||
LeaderBoardEntry executingUserRank = LeaderBoardEntry.builder().build();
|
||||
when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(executingUserRank);
|
||||
LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
|
||||
when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(leaderBoardEntryModel);
|
||||
when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
|
||||
MessageToSend messageToSend = MessageToSend.builder().build();
|
||||
when(templateService.renderEmbedTemplate(eq(LeaderBoardCommand.LEADER_BOARD_POST_EMBED_TEMPLATE), any(LeaderBoardModel.class))).thenReturn(messageToSend);
|
||||
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
|
||||
|
||||
@@ -2,7 +2,9 @@ package dev.sheldan.abstracto.experience.commands;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.service.ChannelService;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
@@ -11,6 +13,7 @@ import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
|
||||
import dev.sheldan.abstracto.experience.models.templates.RankModel;
|
||||
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
|
||||
import dev.sheldan.abstracto.experience.service.ExperienceLevelService;
|
||||
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
|
||||
import dev.sheldan.abstracto.templating.model.MessageToSend;
|
||||
import dev.sheldan.abstracto.templating.service.TemplateService;
|
||||
import dev.sheldan.abstracto.test.command.CommandConfigValidator;
|
||||
@@ -22,8 +25,10 @@ import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
import static dev.sheldan.abstracto.experience.commands.Rank.RANK_POST_EMBED_TEMPLATE;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@@ -47,23 +52,49 @@ public class RankTest {
|
||||
@Mock
|
||||
private ChannelService channelService;
|
||||
|
||||
@Mock
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
|
||||
@Mock
|
||||
private Rank self;
|
||||
|
||||
@Mock
|
||||
private AUserInAServer aUserInAServer;
|
||||
|
||||
@Mock
|
||||
private UserExperienceManagementService userExperienceManagementService;
|
||||
|
||||
@Test
|
||||
public void testRankExecution() {
|
||||
CommandContext context = CommandTestUtilities.getNoParameters();
|
||||
LeaderBoardEntry leaderBoardEntry = Mockito.mock(LeaderBoardEntry.class);
|
||||
when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(leaderBoardEntry);
|
||||
LeaderBoardEntryModel leaderBoardEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
|
||||
when(converter.fromLeaderBoardEntry(leaderBoardEntry)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
|
||||
when(self.renderAndSendRank(eq(context), any(RankModel.class), eq(leaderBoardEntryModel))).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
|
||||
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRenderAndSend() {
|
||||
int currentLevelValue = 50;
|
||||
long currentExperience = 50L;
|
||||
AExperienceLevel currentLevel = Mockito.mock(AExperienceLevel.class);
|
||||
when(currentLevel.getLevel()).thenReturn(currentLevelValue);
|
||||
AUserExperience aUserExperience = Mockito.mock(AUserExperience.class);
|
||||
when(aUserExperience.getCurrentLevel()).thenReturn(currentLevel);
|
||||
when(aUserExperience.getExperience()).thenReturn(currentExperience);
|
||||
CommandContext context = CommandTestUtilities.getNoParameters();
|
||||
AExperienceLevel currentLevel = AExperienceLevel.builder().level(currentLevelValue).build();
|
||||
AUserExperience aUserExperience = AUserExperience.builder().experience(currentExperience).currentLevel(currentLevel).build();
|
||||
LeaderBoardEntry leaderBoardEntry = LeaderBoardEntry.builder().experience(aUserExperience).build();
|
||||
when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(leaderBoardEntry);
|
||||
LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
|
||||
when(converter.fromLeaderBoardEntry(leaderBoardEntry)).thenReturn(leaderBoardEntryModel);
|
||||
RankModel rankModel = Mockito.mock(RankModel.class);
|
||||
LeaderBoardEntryModel leaderBoardEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
|
||||
when(userInServerManagementService.loadUser(context.getAuthor())).thenReturn(aUserInAServer);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(aUserExperience);
|
||||
when(experienceLevelService.calculateExperienceToNextLevel(currentLevelValue, currentExperience)).thenReturn(140L);
|
||||
MessageToSend messageToSend = MessageToSend.builder().build();
|
||||
when(templateService.renderEmbedTemplate(eq(Rank.RANK_POST_EMBED_TEMPLATE), any(RankModel.class))).thenReturn(messageToSend);
|
||||
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
|
||||
verify(channelService, Mockito.times(1)).sendMessageToSendToChannel(messageToSend, context.getChannel());
|
||||
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
|
||||
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
|
||||
when(templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel)).thenReturn(messageToSend);
|
||||
when(channelService.sendMessageToSendToChannel(messageToSend, context.getChannel())).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
|
||||
testUnit.renderAndSendRank(context, rankModel, leaderBoardEntryModel).join();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -20,6 +20,7 @@ import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@@ -43,11 +44,14 @@ public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
|
||||
LeaderBoardEntry entry2 = getEntry(server, secondExperience, secondRank);
|
||||
List<LeaderBoardEntry> entries = Arrays.asList(entry, entry2);
|
||||
LeaderBoard leaderBoard = LeaderBoard.builder().entries(entries).build();
|
||||
List<LeaderBoardEntryModel> leaderBoardEntryModels = testUnit.fromLeaderBoard(leaderBoard);
|
||||
LeaderBoardEntryModel firstEntry = leaderBoardEntryModels.get(0);
|
||||
Member member = Mockito.mock(Member.class);
|
||||
when(botService.getMemberInServerAsync(server.getId(), entry.getExperience().getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
|
||||
when(botService.getMemberInServerAsync(server.getId(), entry2.getExperience().getUser().getUserReference().getId())).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());
|
||||
LeaderBoardEntryModel secondEntry = leaderBoardEntryModels.get(1);
|
||||
LeaderBoardEntryModel secondEntry = leaderBoardEntryModels.get(1).join();
|
||||
Assert.assertEquals(secondRank, secondEntry.getRank().intValue());
|
||||
Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(entries.size(), leaderBoardEntryModels.size());
|
||||
@@ -63,11 +67,12 @@ public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
|
||||
User user = Mockito.mock(User.class);
|
||||
when(user.getIdLong()).thenReturn(userId);
|
||||
when(member.getUser()).thenReturn(user);
|
||||
when(botService.getMemberInServer(server.getId(), experience.getUser().getUserReference().getId())).thenReturn(member);
|
||||
LeaderBoardEntryModel leaderBoardEntryModel = testUnit.fromLeaderBoardEntry(entry);
|
||||
Assert.assertEquals(1, leaderBoardEntryModel.getRank().intValue());
|
||||
Assert.assertEquals(experience.getUser().getUserReference().getId(), leaderBoardEntryModel.getExperience().getUser().getUserReference().getId());
|
||||
Assert.assertEquals(experience.getUser().getUserReference().getId().longValue(), leaderBoardEntryModel.getMember().getUser().getIdLong());
|
||||
when(botService.getMemberInServerAsync(server.getId(), experience.getUser().getUserReference().getId())).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());
|
||||
}
|
||||
|
||||
private LeaderBoardEntry getEntry(AServer server, Integer experienceParameter, Integer rank) {
|
||||
|
||||
@@ -36,7 +36,6 @@ import static org.mockito.Mockito.*;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
@@ -92,12 +91,21 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
@Mock
|
||||
private AUserExperience userExperience;
|
||||
|
||||
@Mock
|
||||
private AUserExperience userExperience2;
|
||||
|
||||
@Mock
|
||||
private AUserInAServer aUserInAServer;
|
||||
|
||||
@Mock
|
||||
private AUserInAServer aUserInAServer2;
|
||||
|
||||
@Mock
|
||||
private AUser user;
|
||||
|
||||
@Mock
|
||||
private AUser user2;
|
||||
|
||||
@Mock
|
||||
private ServerExperience serverExperience;
|
||||
|
||||
@@ -108,7 +116,10 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
private AServer server;
|
||||
|
||||
@Mock
|
||||
private Member member;
|
||||
private Member firstMember;
|
||||
|
||||
@Mock
|
||||
private Member secondMember;
|
||||
|
||||
private static final Long USER_IN_SERVER_ID = 4L;
|
||||
private static final Long USER_ID = 8L;
|
||||
@@ -166,7 +177,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(botService.isUserInGuild(aUserInAServer)).thenReturn(true);
|
||||
when(roleService.removeRoleFromUserFuture(userExperience.getUser(), userExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
@@ -184,9 +194,8 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(userExperience.getExperience()).thenReturn(199L);
|
||||
AExperienceRole newRole = experienceRoles.get(2);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
AExperienceRole newAwardedRole = experienceRoles.get(3);
|
||||
when(roleService.memberHasRole(member, newRole.getRole())).thenReturn(true);
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(true);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
|
||||
@@ -200,15 +209,14 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
|
||||
AExperienceRole newRole = experienceRoles.get(1);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(newRole);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
AExperienceRole newAwardedRole = experienceRoles.get(3);
|
||||
when(roleService.memberHasRole(member, newRole.getRole())).thenReturn(true);
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(true);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newRole.getRole());
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
|
||||
}
|
||||
|
||||
@@ -220,16 +228,15 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
AExperienceRole previousExperienceRole = null;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
|
||||
when(botService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = experienceRoles.get(1);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
when(roleService.memberHasRole(member, newRole.getRole())).thenReturn(false);
|
||||
when(roleService.addRoleToUserFuture(userExperience.getUser(), newRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
|
||||
verify(roleService, times(1)).addRoleToUserFuture(eq(aUserInAServer), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -242,7 +249,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(userExperience.getExperience()).thenReturn(50L);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
|
||||
when(botService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = null;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
@@ -262,7 +269,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(0);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
|
||||
when(botService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = null;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
@@ -284,10 +291,9 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
|
||||
when(userInServerManagementService.loadUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
when(botService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(userExperience.getExperienceGainDisabled()).thenReturn(true);
|
||||
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
@@ -323,6 +329,8 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(server.getId()).thenReturn(8L);
|
||||
when(botService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(roleService.hasAnyOfTheRoles(eq(firstMember), anyList())).thenReturn(false);
|
||||
when(user.getId()).thenReturn(7L);
|
||||
CompletableFuture<Void> future = testUnit.handleExperienceGain(servers);
|
||||
future.join();
|
||||
@@ -331,35 +339,94 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncNoRoleUserGettingRole() {
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
|
||||
AExperienceRole previousRole = null;
|
||||
public void testSyncNoRoleUserGettingRole2() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
userExperience.setCurrentExperienceRole(null);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(0);
|
||||
executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
|
||||
when(botService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(botService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncUserLosingRole() {
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
|
||||
AExperienceRole previousRole = usedExperienceRoles.get(0);
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = null;
|
||||
executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(roleService.removeRoleFromUserFuture(aUserInAServer, beforeRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertNull(result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncUserKeepRole() {
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
|
||||
AExperienceRole previousRole = usedExperienceRoles.get(0);
|
||||
public void testSyncUserKeepingRole() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(0);
|
||||
executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
|
||||
when(botService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(botService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(true);
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncUserChangingRole() {
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
|
||||
AExperienceRole previousRole = usedExperienceRoles.get(0);
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(1);
|
||||
executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
|
||||
|
||||
when(botService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(botService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -415,39 +482,51 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
|
||||
@Test
|
||||
public void testSyncAllUsers() {
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
|
||||
AExperienceRole firstPreviousRole = null;
|
||||
AExperienceRole firstAfterRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole secondPreviousRole = null;
|
||||
AExperienceRole secondAfterRole = null;
|
||||
AExperienceLevel level0 = AExperienceLevel.builder().level(0).build();
|
||||
AExperienceLevel level1 = AExperienceLevel.builder().level(1).build();
|
||||
AUserExperience experience = AUserExperience.builder().experience(40L).user(MockUtils.getUserObject(3L, server)).currentLevel(level1).build();
|
||||
AUserExperience experience2 = AUserExperience.builder().experience(201L).user(MockUtils.getUserObject(4L, server)).currentLevel(level0).build();
|
||||
List<AUserExperience> experiences = Arrays.asList(experience, experience2);
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(1);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(user.getId()).thenReturn(8L);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(userExperience.getCurrentLevel()).thenReturn(level0);
|
||||
|
||||
when(aUserInAServer2.getUserReference()).thenReturn(user2);
|
||||
when(user2.getId()).thenReturn(9L);
|
||||
when(aUserInAServer2.getServerReference()).thenReturn(server);
|
||||
when(userExperience2.getUser()).thenReturn(aUserInAServer2);
|
||||
when(userExperience2.getCurrentLevel()).thenReturn(level0);
|
||||
|
||||
when(userExperience2.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
|
||||
when(botService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(botService.getMemberInServerAsync(aUserInAServer2)).thenReturn(CompletableFuture.completedFuture(secondMember));
|
||||
|
||||
when(server.getId()).thenReturn(15L);
|
||||
|
||||
List<AUserInAServer> users = experiences.stream().map(AUserExperience::getUser).collect(Collectors.toList());
|
||||
Member firstMember = Mockito.mock(Member.class);
|
||||
when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(firstMember);
|
||||
Member secondMember = Mockito.mock(Member.class);
|
||||
when(botService.getMemberInServer(server, users.get(1).getUserReference())).thenReturn(secondMember);
|
||||
experience.setCurrentExperienceRole(firstPreviousRole);
|
||||
experience2.setCurrentExperienceRole(secondPreviousRole);
|
||||
when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, experience.getLevelOrDefault())).thenReturn(firstAfterRole);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, experience2.getLevelOrDefault())).thenReturn(secondAfterRole);
|
||||
when(botService.getMemberInServer(server, experience.getUser().getUserReference())).thenReturn(firstMember);
|
||||
when(botService.getMemberInServer(server, experience2.getUser().getUserReference())).thenReturn(secondMember);
|
||||
when(botService.isUserInGuild(experience.getUser())).thenReturn(true);
|
||||
when(botService.isUserInGuild(experience2.getUser())).thenReturn(true);
|
||||
when(roleService.addRoleToUserFuture(experience.getUser(), firstAfterRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.memberHasRole(firstMember, firstAfterRole.getRole())).thenReturn(false);
|
||||
List<CompletableFuture<RoleCalculationResult>> futures = testUnit.syncUserRoles(server);
|
||||
RoleCalculationResult result = futures.get(0).join();
|
||||
RoleCalculationResult result2 = futures.get(1).join();
|
||||
Assert.assertEquals(firstAfterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
Assert.assertNull(result2.getExperienceRoleId());
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(botService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(botService.getMemberInServerAsync(userExperience2.getUser())).thenReturn(CompletableFuture.completedFuture(secondMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.memberHasRole(secondMember, afterRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
List<AUserExperience> experiences = Arrays.asList(userExperience, userExperience2);
|
||||
when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
|
||||
List<CompletableFuture<RoleCalculationResult>> calculationFutures = testUnit.syncUserRoles(server);
|
||||
verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, beforeRole.getRole().getId());
|
||||
verify(roleService, times(0)).addRoleToMemberFuture(secondMember, afterRole.getRole().getId());
|
||||
RoleCalculationResult firstResult = calculationFutures.get(0).join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), firstResult.getExperienceRoleId());
|
||||
RoleCalculationResult secondResult = calculationFutures.get(1).join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), secondResult.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -534,12 +613,12 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(userInServerManagementService.loadUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
|
||||
when(botService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(botService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(botService.isUserInGuild(userExperience.getUser())).thenReturn(true);
|
||||
when(server.getId()).thenReturn(SERVER_ID);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
}
|
||||
@@ -556,37 +635,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
|
||||
}
|
||||
|
||||
private void executeSyncSingleUserTest(AServer server, List<AExperienceRole> usedExperienceRoles, AExperienceRole previousRole, AExperienceRole afterRole) {
|
||||
AExperienceLevel level0 = AExperienceLevel.builder().level(0).build();
|
||||
AUserExperience experience = AUserExperience.builder().experience(40L).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
|
||||
List<AUserExperience> experiences = Arrays.asList(experience);
|
||||
|
||||
List<AUserInAServer> users = experiences.stream().map(AUserExperience::getUser).collect(Collectors.toList());
|
||||
when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(member);
|
||||
experience.setCurrentExperienceRole(previousRole);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, experience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(botService.getMemberInServer(server, experience.getUser().getUserReference())).thenReturn(member);
|
||||
users.forEach(innerUser -> when(botService.isUserInGuild(innerUser)).thenReturn(true));
|
||||
if(afterRole != null) {
|
||||
when(roleService.addRoleToUserFuture(experience.getUser(), afterRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
}
|
||||
if(previousRole != null) {
|
||||
when(roleService.removeRoleFromUserFuture(experience.getUser(), previousRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
}
|
||||
if(afterRole != null && previousRole != null) {
|
||||
boolean sameRole = previousRole.getRole().getId().equals(afterRole.getRole().getId());
|
||||
when(roleService.memberHasRole(member, afterRole.getRole())).thenReturn(sameRole);
|
||||
}
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(experience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
if(afterRole != null) {
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
} else {
|
||||
Assert.assertNull(result.getExperienceRoleId());
|
||||
}
|
||||
}
|
||||
|
||||
private void executeLeaderBoardTest(AServer server, Integer page) {
|
||||
int pageSize = 10;
|
||||
List<AUserExperience> experiences = getUserExperiences(pageSize, server);
|
||||
|
||||
Reference in New Issue
Block a user