Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-04-16 04:21:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-68] adding invite filter with commands to allow/disallow invites, remove stored filtered invite links and show filtered invite links

Browse Source 
removing database entities from command context
This commit is contained in:
Sheldan
2021-01-23 15:33:00 +01:00
parent fb3ed69650
commit 2a2a3aea70
182 changed files with 2571 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommand.java
View File

@@ -10,7 +10,11 @@ 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.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
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;
@@ -51,20 +55,26 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
@Autowired
private LeaderBoardModelConverter converter;
@Autowired
private ServerManagementService serverManagementService;
@Autowired
private UserInServerManagementService userInServerManagementService;
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
List<Object> parameters = commandContext.getParameters().getParameters();
// 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);
AServer server = serverManagementService.loadServer(commandContext.getGuild());
LeaderBoard leaderBoard = userExperienceService.findLeaderBoardData(server, page);
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());
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(aUserInAServer);
CompletableFuture<LeaderBoardEntryModel> userRankFuture = converter.fromLeaderBoardEntry(userRank);
futures.add(userRankFuture);
return FutureUtils.toSingleFutureGeneric(futures).thenCompose(aVoid -> {

8
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/ListDisabledExperienceRoles.java
View File

@@ -9,8 +9,10 @@ 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.FullRole;
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.utils.FutureUtils;
import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
@@ -40,9 +42,13 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
@Autowired
private ChannelService channelService;
@Autowired
private ServerManagementService serverManagementService;
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
List<ADisabledExpRole> disabledRolesForServer = disabledExpRoleManagementService.getDisabledRolesForServer(commandContext.getUserInitiatedContext().getServer());
AServer server = serverManagementService.loadServer(commandContext.getGuild());
List<ADisabledExpRole> disabledRolesForServer = disabledExpRoleManagementService.getDisabledRolesForServer(server);
DisabledExperienceRolesModel disabledExperienceRolesModel = (DisabledExperienceRolesModel) ContextConverter.fromCommandContext(commandContext, DisabledExperienceRolesModel.class);
disabledRolesForServer.forEach(aDisabledExpRole -> {
FullRole role = FullRole

3
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/Rank.java
View File

@@ -67,7 +67,8 @@ public class Rank extends AbstractConditionableCommand {
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
RankModel rankModel = (RankModel) ContextConverter.slimFromCommandContext(commandContext, RankModel.class);
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(aUserInAServer);
CompletableFuture<LeaderBoardEntryModel> future = converter.fromLeaderBoardEntry(userRank);
return future.thenCompose(leaderBoardEntryModel ->
self.renderAndSendRank(commandContext, rankModel, leaderBoardEntryModel)

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

@@ -44,7 +44,7 @@ public class SetExpRole extends AbstractConditionableCommand {
Integer level = (Integer) commandContext.getParameters().getParameters().get(0);
Role role = (Role) commandContext.getParameters().getParameters().get(1);
log.info("Setting role {} to be used for level {} on server {}", role.getId(), level, role.getGuild().getId());
return experienceRoleService.setRoleToLevel(role, level, commandContext.getUserInitiatedContext().getChannel())
return experienceRoleService.setRoleToLevel(role, level, commandContext.getChannel().getIdLong())
.thenApply(aVoid -> CommandResult.fromSuccess());
}

8
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/SyncRoles.java
View File

@@ -8,6 +8,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import lombok.extern.slf4j.Slf4j;
@@ -31,11 +32,14 @@ public class SyncRoles extends AbstractConditionableCommand {
@Autowired
private AUserExperienceService userExperienceService;
@Autowired
private ServerManagementService serverManagementService;
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
AServer server = commandContext.getUserInitiatedContext().getServer();
AServer server = serverManagementService.loadServer(commandContext.getGuild());
log.info("Synchronizing roles on server {}", server.getId());
return userExperienceService.syncUserRolesWithFeedback(server, commandContext.getUserInitiatedContext().getChannel())
return userExperienceService.syncUserRolesWithFeedback(server, commandContext.getChannel().getIdLong())
.thenApply(aVoid -> CommandResult.fromIgnored());
}

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

@@ -37,7 +37,7 @@ public class UnSetExpRole extends AbstractConditionableCommand {
ARole actualRole = roleManagementService.findRole(role.getId());
// do not check for the existence of the role, because if the role was deleted, users should be able
// to get rid of it in the configuration
return experienceRoleService.unsetRole(actualRole, commandContext.getUserInitiatedContext().getChannel())
return experienceRoleService.unsetRole(actualRole, commandContext.getChannel().getIdLong())
.thenApply(aVoid -> CommandResult.fromSuccess());
}

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

@@ -4,10 +4,8 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.CompletableFutureList;
@@ -79,6 +77,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
@Autowired
private ServerManagementService serverManagementService;
@Autowired
private ChannelManagementService channelManagementService;
@Autowired
private AUserExperienceServiceBean self;
@@ -403,10 +404,11 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
/**
* Synchronizes the roles of all the users and provides feedback to the user executing
* @param server The {@link AServer} to update users for
* @param channel The {@link AChannel} in which the {@link dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel}
* @param channelId The ID of the channel in which the {@link dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel} should be posted to
*/
@Override
public CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, AChannel channel) {
public CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, Long channelId) {
AChannel channel = channelManagementService.loadChannel(channelId);
List<AUserExperience> aUserExperiences = userExperienceManagementService.loadAllUsers(server);
log.info("Found {} users to synchronize", aUserExperiences.size());
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);

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

@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.experience.service;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
import dev.sheldan.abstracto.core.utils.CompletableFutureList;
import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
@@ -42,6 +43,9 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
@Autowired
private RoleManagementService roleManagementService;
@Autowired
private ChannelManagementService channelManagementService;
/**
* UnSets the current configuration for the passed level, and sets the {@link ARole} to be used for this level
* in the given {@link AServer}
@@ -49,10 +53,10 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
* @param level The level the {@link ARole} should be awarded at
*/
@Override
public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, AChannel feedbackChannel) {
public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, Long channelId) {
Long roleId = role.getIdLong();
ARole aRole = roleManagementService.findRole(roleId);
return unsetRole(aRole, feedbackChannel).thenAccept(aVoid ->
return unsetRole(aRole, channelId).thenAccept(aVoid ->
self.unsetRoleInDb(level, roleId)
);
}
@@ -73,7 +77,8 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
* configuration
*/
@Override
public CompletableFuture<Void> unsetRole(ARole role, AChannel feedbackChannel) {
public CompletableFuture<Void> unsetRole(ARole role, Long feedbackChannelId) {
AChannel channel = channelManagementService.loadChannel(feedbackChannelId);
Optional<AExperienceRole> roleInServerOptional = experienceRoleManagementService.getRoleInServerOptional(role);
if(roleInServerOptional.isPresent()) {
AExperienceRole roleInServer = roleInServerOptional.get();
@@ -82,7 +87,7 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(role.getServer());
roles.removeIf(role1 -> role1.getId().equals(roleInServer.getId()));
Long roleId = role.getId();
CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), feedbackChannel,
CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), channel,
(AUserExperience ex) -> userExperienceService.updateUserRole(ex, roles, ex.getLevelOrDefault()));
return calculationResults.getMainFuture().thenAccept(aVoid ->
self.persistData(calculationResults, roleId)

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

@@ -5,7 +5,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import net.dv8tion.jda.api.entities.Member;
@@ -35,7 +34,7 @@ public class DisableExpGainTest {
@Test
public void testDisableExpForMember() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
AUserInAServer parameterUser = Mockito.mock(AUserInAServer.class);
Member member = Mockito.mock(Member.class);
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);

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

@@ -5,7 +5,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import net.dv8tion.jda.api.entities.Member;
@@ -35,7 +34,7 @@ public class EnableExpGainTest {
@Test
public void testEnableExpForMember() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
AUserInAServer parameterUser = Mockito.mock(AUserInAServer.class);
Member member = Mockito.mock(Member.class);
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);

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

@@ -2,7 +2,11 @@ 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.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
import dev.sheldan.abstracto.experience.models.LeaderBoard;
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
@@ -17,6 +21,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.ArrayList;
@@ -43,6 +48,12 @@ public class LeaderBoardCommandTest {
@Mock
private LeaderBoardModelConverter converter;
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private ServerManagementService serverManagementService;
@Test
public void testLeaderBoardWithNoParameter() {
testLeaderBoardCommand(CommandTestUtilities.getNoParameters(), 1);
@@ -54,11 +65,15 @@ public class LeaderBoardCommandTest {
}
private void testLeaderBoardCommand(CommandContext context, int expectedPage) {
LeaderBoard leaderBoard = LeaderBoard.builder().build();
when(userExperienceService.findLeaderBoardData(context.getUserInitiatedContext().getServer(), expectedPage)).thenReturn(leaderBoard);
LeaderBoard leaderBoard = Mockito.mock(LeaderBoard.class);
AServer server = Mockito.mock(AServer.class);
when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUser(context.getAuthor())).thenReturn(userInAServer);
when(userExperienceService.findLeaderBoardData(server, expectedPage)).thenReturn(leaderBoard);
when(converter.fromLeaderBoard(leaderBoard)).thenReturn(new ArrayList<>());
LeaderBoardEntry executingUserRank = LeaderBoardEntry.builder().build();
when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(executingUserRank);
when(userExperienceService.getRankOfUserInServer(userInAServer)).thenReturn(executingUserRank);
LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
MessageToSend messageToSend = MessageToSend.builder().build();

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

@@ -6,6 +6,7 @@ import dev.sheldan.abstracto.core.models.database.ARole;
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.experience.models.database.ADisabledExpRole;
import dev.sheldan.abstracto.experience.models.templates.DisabledExperienceRolesModel;
import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
@@ -41,10 +42,14 @@ public class ListDisabledExperienceRolesTest {
@Mock
private ChannelService channelService;
@Mock
private ServerManagementService serverManagementService;
@Test
public void testCommandExecutionNoRolesFound() {
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = context.getUserInitiatedContext().getServer();
AServer server = Mockito.mock(AServer.class);
when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
when(channelService.sendEmbedTemplateInChannel(eq("list_disabled_experience_roles"),
any(DisabledExperienceRolesModel.class), eq(context.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
@@ -56,7 +61,7 @@ public class ListDisabledExperienceRolesTest {
@Test
public void testCommandExecutionRolesFound() {
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = context.getUserInitiatedContext().getServer();
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();
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(Arrays.asList(disabledExpRole1, disabledExpRole2));
@@ -64,6 +69,7 @@ public class ListDisabledExperienceRolesTest {
Role role2 = Mockito.mock(Role.class);
when(roleService.getRoleFromGuild(disabledExpRole1.getRole())).thenReturn(role1);
when(roleService.getRoleFromGuild(disabledExpRole2.getRole())).thenReturn(role2);
when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
when(channelService.sendEmbedTemplateInChannel(eq("list_disabled_experience_roles"),
any(DisabledExperienceRolesModel.class), eq(context.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);

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

@@ -68,7 +68,8 @@ public class RankTest {
public void testRankExecution() {
CommandContext context = CommandTestUtilities.getNoParameters();
LeaderBoardEntry leaderBoardEntry = Mockito.mock(LeaderBoardEntry.class);
when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(leaderBoardEntry);
when(userInServerManagementService.loadUser(context.getAuthor())).thenReturn(aUserInAServer);
when(userExperienceService.getRankOfUserInServer(aUserInAServer)).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));

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

@@ -35,14 +35,17 @@ public class SetExpRoleTest {
@Mock
private RoleManagementService roleManagementService;
private static final Long CHANNEL_ID = 4L;
@Test
public void setExpRole() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
Role roleToChange = Mockito.mock(Role.class);
when(roleToChange.getGuild()).thenReturn(noParameters.getGuild());
Integer levelToSetTo = 4;
when(noParameters.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, roleToChange));
when(experienceRoleService.setRoleToLevel(roleToChange, levelToSetTo, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
when(experienceRoleService.setRoleToLevel(roleToChange, levelToSetTo, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
}

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

@@ -2,8 +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.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
@@ -11,6 +12,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.concurrent.CompletableFuture;
@@ -26,12 +28,21 @@ public class SyncRolesTest {
@Mock
private AUserExperienceService userExperienceService;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private ServerManagementService serverManagementService;
private static final Long CHANNEL_ID = 4L;
@Test
public void executeCommand() {
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = context.getUserInitiatedContext().getServer();
AChannel channel = context.getUserInitiatedContext().getChannel();
when(userExperienceService.syncUserRolesWithFeedback(server, channel)).thenReturn(CompletableFuture.completedFuture(null));
AServer server = Mockito.mock(AServer.class);
when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
when(context.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
when(userExperienceService.syncUserRolesWithFeedback(server, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
}

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

@@ -5,7 +5,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import org.junit.Test;
@@ -32,14 +31,17 @@ public class UnSetExpRoleTest {
@Mock
private RoleManagementService roleManagementService;
private static final Long CHANNEL_ID = 4L;
@Test
public void setUnSetExpRole() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
ARole changedRole = Mockito.mock(ARole.class);
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(changedRole));
when(context.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
ARole actualRole = Mockito.mock(ARole.class);
when(roleManagementService.findRole(changedRole.getId())).thenReturn(actualRole);
when(experienceRoleService.unsetRole(actualRole, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
when(experienceRoleService.unsetRole(actualRole, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
}

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
@@ -67,6 +68,9 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
@Mock
private TemplateService templateService;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private DisabledExpRoleManagementService disabledExpRoleManagementService;
@@ -124,6 +128,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
private static final Long USER_IN_SERVER_ID = 4L;
private static final Long USER_ID = 8L;
private static final Long SERVER_ID = 9L;
private static final Long CHANNEL_ID = 7L;
@Test
public void testCalculateLevelTooLow() {
@@ -583,7 +588,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
@Test
public void testSyncRolesWithFeedBack() {
AChannel channel = AChannel.builder().id(2L).build();
AChannel channel = Mockito.mock(AChannel.class);
List<AUserExperience> experiences = getUserExperiences(25, server);
checkStatusMessages(server, channel, experiences, 13);
@@ -591,7 +596,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
@Test
public void testSyncRolesWithNoUsers() {
AChannel channel = AChannel.builder().id(2L).build();
AChannel channel = Mockito.mock(AChannel.class);
List<AUserExperience> experiences = new ArrayList<>();
checkStatusMessages(server, channel, experiences, 1);
@@ -631,7 +636,8 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
Message statusMessageJDA = Mockito.mock(Message.class);
when(statusMessageJDA.getIdLong()).thenReturn(messageId);
when(messageService.createStatusMessage(statusMessage, channel)).thenReturn(CompletableFuture.completedFuture(statusMessageJDA));
testUnit.syncUserRolesWithFeedback(server, channel);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(channel);
testUnit.syncUserRolesWithFeedback(server, CHANNEL_ID);
verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
}

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

@@ -4,6 +4,7 @@ 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;
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
import dev.sheldan.abstracto.core.utils.CompletableFutureList;
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
@@ -48,17 +49,21 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
@Mock
private RoleManagementService roleManagementService;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private ExperienceRoleServiceBean self;
@Mock
private AServer server;
private static final Long CHANNEL_ID = 4L;
@Test
public void testSettingRoleToLevelWithoutOldUsers() {
Integer levelCount = 10;
AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
Role roleToChange = Mockito.mock(Role.class);
ARole role = Mockito.mock(ARole.class);
Long roleId = 5L;
@@ -66,10 +71,11 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
when(roleManagementService.findRole(roleId)).thenReturn(role);
AExperienceRole previousExperienceRole = AExperienceRole.builder().role(role).roleServer(server).level(level).build();
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, getFeedbackChannel(server));
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
future.join();
verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
verify(self, times(1)).unsetRoleInDb(levelCount, roleId);
}
@Test
@@ -105,12 +111,13 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
AExperienceRole newExperienceRole = AExperienceRole.builder().role(newRoleToAward).id(newRoleToAward.getId()).roleServer(server).level(level).build();
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(new ArrayList<>(Arrays.asList(newExperienceRole, previousExperienceRole)));
AChannel feedBackChannel = getFeedbackChannel(server);
List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
futures.add(CompletableFuture.completedFuture(null));
AChannel feedbackChannel = Mockito.mock(AChannel.class);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(feedbackChannel);
CompletableFutureList<RoleCalculationResult> futuresList = new CompletableFutureList<>(futures);
when(userExperienceService.executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedBackChannel), any())).thenReturn(futuresList);
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, feedBackChannel);
when(userExperienceService.executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedbackChannel), any())).thenReturn(futuresList);
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
future.join();
verify(experienceRoleManagementService, times(0)).unsetRole(previousExperienceRole);
}