[AB-136] replacing some rare occurrences where fake objects where used for actual database operations

replacing a few sync commands with async commands
refactoring parameters in assignable role place service bean
fixing emote parameter handler to also consider default emojis
removing unused description in command
replacing some ARole parameters with Role parameters, so we can be sure they exists
added a few TODOs marking exception changes required

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/DisableExpForRole.java

@@ -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.ARole;
+import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -25,13 +26,17 @@ public class DisableExpForRole extends AbstractConditionableCommand {
     @Autowired
     private DisabledExpRoleManagementService disabledExpRoleManagementService;
 
+    @Autowired
+    private RoleManagementService roleManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         checkParameters(commandContext);
         List<Object> parameters = commandContext.getParameters().getParameters();
         ARole role = (ARole) parameters.get(0);
-        if(!disabledExpRoleManagementService.isExperienceDisabledForRole(role)) {
-            disabledExpRoleManagementService.setRoleToBeDisabledForExp(role);
+        ARole actualRole = roleManagementService.findRole(role.getId());
+        if(!disabledExpRoleManagementService.isExperienceDisabledForRole(actualRole)) {
+            disabledExpRoleManagementService.setRoleToBeDisabledForExp(actualRole);
         }
         return CommandResult.fromSuccess();
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/EnableExpForRole.java

@@ -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.ARole;
+import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -25,12 +26,16 @@ public class EnableExpForRole extends AbstractConditionableCommand {
     @Autowired
     private DisabledExpRoleManagementService disabledExpRoleManagementService;
 
+    @Autowired
+    private RoleManagementService roleManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         checkParameters(commandContext);
         ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
-        if(disabledExpRoleManagementService.isExperienceDisabledForRole(role)) {
-            disabledExpRoleManagementService.removeRoleToBeDisabledForExp(role);
+        ARole actualRole = roleManagementService.findRole(role.getId());
+        if(disabledExpRoleManagementService.isExperienceDisabledForRole(actualRole)) {
+            disabledExpRoleManagementService.removeRoleToBeDisabledForExp(actualRole);
         }
         return CommandResult.fromSuccess();
     }

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

@@ -68,6 +68,7 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
                 .templated(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
+                .async(true)
                 .aliases(aliases)
                 .parameters(parameters)
                 .help(helpInfo)

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

@@ -9,13 +9,12 @@ import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValida
 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.exception.RoleNotFoundInGuildException;
-import dev.sheldan.abstracto.core.models.database.ARole;
-import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
 import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Role;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -37,16 +36,15 @@ public class SetExpRole extends AbstractConditionableCommand {
     @Autowired
     private RoleService roleService;
 
+    @Autowired
+    private RoleManagementService roleManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         checkParameters(commandContext);
         Integer level = (Integer) commandContext.getParameters().getParameters().get(0);
-        ARole role = (ARole) commandContext.getParameters().getParameters().get(1);
-        AServer server = commandContext.getUserInitiatedContext().getServer();
-        if(!roleService.isRoleInServer(role)) {
-            throw new RoleNotFoundInGuildException(role.getId(), server.getId());
-        }
-        log.info("Setting role  {} to be used for level {} on server {}", role.getId(), level, server.getId());
+        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())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
@@ -56,7 +54,7 @@ public class SetExpRole extends AbstractConditionableCommand {
         List<Parameter> parameters = new ArrayList<>();
         List<ParameterValidator> levelValidators = Arrays.asList(MinIntegerValueValidator.min(0L));
         parameters.add(Parameter.builder().name("level").validators(levelValidators).templated(true).type(Integer.class).build());
-        parameters.add(Parameter.builder().name("role").templated(true).type(ARole.class).build());
+        parameters.add(Parameter.builder().name("role").templated(true).type(Role.class).build());
         HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
         return CommandConfiguration.builder()
                 .name("setExpRole")

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

@@ -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.ARole;
+import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -27,13 +28,17 @@ public class UnSetExpRole extends AbstractConditionableCommand {
     @Autowired
     private ExperienceRoleService experienceRoleService;
 
+    @Autowired
+    private RoleManagementService roleManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         checkParameters(commandContext);
         ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
+        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(role, commandContext.getUserInitiatedContext().getChannel())
+        return experienceRoleService.unsetRole(actualRole, commandContext.getUserInitiatedContext().getChannel())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

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

@@ -12,6 +12,7 @@ import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
 import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Role;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -48,9 +49,10 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
      * @param level The level the {@link ARole} should be awarded at
      */
     @Override
-    public CompletableFuture<Void> setRoleToLevel(ARole role, Integer level, AChannel feedbackChannel) {
-        Long roleId = role.getId();
-        return unsetRole(role, feedbackChannel).thenAccept(aVoid ->
+    public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, AChannel feedbackChannel) {
+        Long roleId = role.getIdLong();
+        ARole aRole = roleManagementService.findRole(roleId);
+        return unsetRole(aRole, feedbackChannel).thenAccept(aVoid ->
             self.unsetRoleInDb(level, roleId)
         );
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/DisableExpForRoleTest.java

@@ -5,8 +5,8 @@ import dev.sheldan.abstracto.core.command.exception.InsufficientParametersExcept
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 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.management.DisabledExpRoleManagementService;
-import dev.sheldan.abstracto.test.MockUtils;
 import dev.sheldan.abstracto.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.test.command.CommandTestUtilities;
 import lombok.extern.slf4j.Slf4j;
@@ -14,6 +14,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;
@@ -27,6 +28,9 @@ public class DisableExpForRoleTest {
     @InjectMocks
     private DisableExpForRole testUnit;
 
+    @Mock
+    private RoleManagementService roleManagementService;
+
     @Mock
     private DisabledExpRoleManagementService disabledExpRoleManagementService;
 
@@ -51,11 +55,14 @@ public class DisableExpForRoleTest {
     }
 
     private void executeDisableExpForRoleTest(boolean value, int wantedNumberOfInvocations) {
-        ARole disabledRole = MockUtils.getRole(1L, MockUtils.getServer());
-        CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(disabledRole));
-        when(disabledExpRoleManagementService.isExperienceDisabledForRole(disabledRole)).thenReturn(value);
+        ARole parameterRole = Mockito.mock(ARole.class);
+        ARole actualRole = Mockito.mock(ARole.class);
+        when(parameterRole.getId()).thenReturn(5L);
+        CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(parameterRole));
+        when(roleManagementService.findRole(parameterRole.getId())).thenReturn(actualRole);
+        when(disabledExpRoleManagementService.isExperienceDisabledForRole(actualRole)).thenReturn(value);
         CommandResult result = testUnit.execute(context);
-        verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).setRoleToBeDisabledForExp(disabledRole);
+        verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).setRoleToBeDisabledForExp(actualRole);
         CommandTestUtilities.checkSuccessfulCompletion(result);
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/EnableExpForRoleTest.java

@@ -5,14 +5,15 @@ import dev.sheldan.abstracto.core.command.exception.InsufficientParametersExcept
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 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.management.DisabledExpRoleManagementService;
-import dev.sheldan.abstracto.test.MockUtils;
 import dev.sheldan.abstracto.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.test.command.CommandTestUtilities;
 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;
@@ -28,6 +29,9 @@ public class EnableExpForRoleTest {
     @Mock
     private DisabledExpRoleManagementService disabledExpRoleManagementService;
 
+    @Mock
+    private RoleManagementService roleManagementService;
+
     @Test(expected = InsufficientParametersException.class)
     public void testTooLittleParameters() {
         CommandTestUtilities.executeNoParametersTest(testUnit);
@@ -49,11 +53,15 @@ public class EnableExpForRoleTest {
     }
 
     private void executeEnableExpForRoleTest(boolean value, int wantedNumberOfInvocations) {
-        ARole disabledRole = MockUtils.getRole(1L, MockUtils.getServer());
-        CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(disabledRole));
-        when(disabledExpRoleManagementService.isExperienceDisabledForRole(disabledRole)).thenReturn(value);
+        ARole roleParameter = Mockito.mock(ARole.class);
+        CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(roleParameter));
+        Long roleId = 8L;
+        when(roleParameter.getId()).thenReturn(roleId);
+        ARole actualRole = Mockito.mock(ARole.class);
+        when(roleManagementService.findRole(roleId)).thenReturn(actualRole);
+        when(disabledExpRoleManagementService.isExperienceDisabledForRole(actualRole)).thenReturn(value);
         CommandResult result = testUnit.execute(context);
-        verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).removeRoleToBeDisabledForExp(disabledRole);
+        verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).removeRoleToBeDisabledForExp(actualRole);
         CommandTestUtilities.checkSuccessfulCompletion(result);
     }
 

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

@@ -4,17 +4,17 @@ import dev.sheldan.abstracto.core.command.exception.IncorrectParameterException;
 import dev.sheldan.abstracto.core.command.exception.InsufficientParametersException;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.exception.RoleNotFoundInGuildException;
-import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
-import dev.sheldan.abstracto.test.MockUtils;
 import dev.sheldan.abstracto.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.api.entities.Role;
 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;
@@ -34,6 +34,9 @@ public class SetExpRoleTest {
     @Mock
     private RoleService roleService;
 
+    @Mock
+    private RoleManagementService roleManagementService;
+
     @Test(expected = InsufficientParametersException.class)
     public void testTooLittleParameters() {
         CommandTestUtilities.executeNoParametersTestAsync(testUnit);
@@ -59,25 +62,15 @@ public class SetExpRoleTest {
     @Test
     public void setExpRole() {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
+        Role roleToChange = Mockito.mock(Role.class);
+        when(roleToChange.getGuild()).thenReturn(noParameters.getGuild());
         Integer levelToSetTo = 4;
-        CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, changedRole));
-        when(roleService.isRoleInServer(changedRole)).thenReturn(true);
-        when(experienceRoleService.setRoleToLevel(changedRole, levelToSetTo, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
+        CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, roleToChange));
+        when(experienceRoleService.setRoleToLevel(roleToChange, levelToSetTo, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }
 
-    @Test(expected = RoleNotFoundInGuildException.class)
-    public void setExpRoleNotExistingOnServer() {
-        CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
-        Integer levelToSetTo = 4;
-        CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, changedRole));
-        when(roleService.isRoleInServer(changedRole)).thenReturn(false);
-        testUnit.executeAsync(context);
-    }
-
     @Test
     public void validateCommand() {
         CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.command.exception.InsufficientParametersExcept
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 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.test.MockUtils;
 import dev.sheldan.abstracto.test.command.CommandConfigValidator;
@@ -13,6 +14,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,6 +31,9 @@ public class UnSetExpRoleTest {
     @Mock
     private ExperienceRoleService experienceRoleService;
 
+    @Mock
+    private RoleManagementService roleManagementService;
+
     @Test(expected = InsufficientParametersException.class)
     public void testTooLittleParameters() {
         CommandTestUtilities.executeNoParametersTestAsync(testUnit);
@@ -44,7 +49,9 @@ public class UnSetExpRoleTest {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
         ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
         CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(changedRole));
-        when(experienceRoleService.unsetRole(changedRole, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
+        ARole actualRole = Mockito.mock(ARole.class);
+        when(roleManagementService.findRole(changedRole.getId())).thenReturn(actualRole);
+        when(experienceRoleService.unsetRole(actualRole, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }

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

@@ -14,11 +14,13 @@ import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
 import dev.sheldan.abstracto.test.MockUtils;
+import net.dv8tion.jda.api.entities.Role;
 import org.junit.Assert;
 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;
@@ -56,9 +58,13 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         AServer server = MockUtils.getServer();
         Integer levelCount = 10;
         AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
-        ARole roleToChange = getRole(1L, server);
-        AExperienceRole previousExperienceRole = AExperienceRole.builder().role(roleToChange).roleServer(server).level(level).build();
-        when(experienceRoleManagementService.getRoleInServerOptional(roleToChange)).thenReturn(Optional.of(previousExperienceRole));
+        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(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
         CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, getFeedbackChannel(server));
 
         future.join();
@@ -86,14 +92,19 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         AServer server = MockUtils.getServer();
         Integer levelCount = 10;
         AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
-        ARole roleToChange = getRole(1L, server);
+        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(role.getServer()).thenReturn(server);
         ARole newRoleToAward = getRole(2L, server);
         AUserExperience firstUser = AUserExperience.builder().build();
         AUserExperience secondUser = AUserExperience.builder().build();
         List<AUserExperience> users = Arrays.asList(firstUser, secondUser);
-        AExperienceRole previousExperienceRole = AExperienceRole.builder().role(roleToChange).id(roleToChange.getId()).roleServer(server).level(level).users(users).build();
+        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();
-        when(experienceRoleManagementService.getRoleInServerOptional(roleToChange)).thenReturn(Optional.of(previousExperienceRole));
+        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<>();

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceRoleService.java

@@ -6,6 +6,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import net.dv8tion.jda.api.entities.Role;
 
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -20,7 +21,7 @@ public interface ExperienceRoleService {
      * @param role The {@link ARole} to set the level to
      * @param level The level the {@link ARole} should be awarded at
      */
-    CompletableFuture<Void> setRoleToLevel(ARole role, Integer level, AChannel channel);
+    CompletableFuture<Void> setRoleToLevel(Role role, Integer level, AChannel channel);
 
     /**
      * Removes the role from the {@link dev.sheldan.abstracto.experience.models.database.AExperienceRole} configuration