added tests for experience tracking module

refactored some things in experience tracking
changed the paging behaviour for leader board and added check for negative numbers
fixed rank not being correct for further pages
added test-common module to have some common code für tests
fixed command creation

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/pom.xml

@@ -17,6 +17,14 @@
             <artifactId>experience-tracking-int</artifactId>
             <version>${project.version}</version>
         </dependency>
+
+        <dependency>
+            <groupId>dev.sheldan.abstracto</groupId>
+            <artifactId>test-commons</artifactId>
+            <version>${project.version}</version>
+            <type>test-jar</type>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

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

@@ -24,7 +24,9 @@ public class DisableExpForRole extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
-        ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
+        checkParameters(commandContext);
+        List<Object> parameters = commandContext.getParameters().getParameters();
+        ARole role = (ARole) parameters.get(0);
         if(!disabledExpRoleManagementService.isExperienceDisabledForRole(role)) {
             disabledExpRoleManagementService.setRoleToBeDisabledForExp(role);
         }

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

@@ -29,6 +29,7 @@ public class DisableExpGain extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         Member para = (Member) commandContext.getParameters().getParameters().get(0);
         AUserInAServer userInAServer = userInServerManagementService.loadUser(para);
         aUserExperienceService.disableExperienceForUser(userInAServer);

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

@@ -24,6 +24,7 @@ public class EnableExpForRole extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
         if(disabledExpRoleManagementService.isExperienceDisabledForRole(role)) {
             disabledExpRoleManagementService.removeRoleToBeDisabledForExp(role);

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

@@ -29,6 +29,7 @@ public class EnableExpGain extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         Member para = (Member) commandContext.getParameters().getParameters().get(0);
         AUserInAServer userInAServer = userInServerManagementService.loadUser(para);
         aUserExperienceService.enableExperienceForUser(userInAServer);

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

@@ -27,6 +27,7 @@ public class ExpScale extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         Double scale = (Double) commandContext.getParameters().getParameters().get(0);
         Long guildId = commandContext.getGuild().getIdLong();
         configService.setDoubleValue(EXP_MULTIPLIER_KEY, guildId, scale);

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

@@ -15,7 +15,6 @@ import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
 import dev.sheldan.abstracto.experience.models.templates.LeaderBoardModel;
 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;
@@ -33,9 +32,6 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
     @Autowired
     private AUserExperienceService userExperienceService;
 
-    @Autowired
-    private UserExperienceManagementService userExperienceManagementService;
-
     @Autowired
     private TemplateService templateService;
 
@@ -48,9 +44,10 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(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) : 0;
+        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));

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

@@ -35,6 +35,7 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         List<ADisabledExpRole> disabledRolesForServer = disabledExpRoleManagementService.getDisabledRolesForServer(commandContext.getUserInitiatedContext().getServer());
         DisabledExperienceRolesModel disabledExperienceRolesModel = (DisabledExperienceRolesModel) ContextConverter.fromCommandContext(commandContext, DisabledExperienceRolesModel.class);
         disabledRolesForServer.forEach(aDisabledExpRole -> {

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

@@ -41,11 +41,12 @@ public class Rank extends AbstractConditionableCommand {
     private ExperienceLevelService experienceLevelService;
 
     @Autowired
-    protected ChannelService channelService;
+    private ChannelService channelService;
 
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         RankModel rankModel = (RankModel) ContextConverter.fromCommandContext(commandContext, RankModel.class);
         LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
         rankModel.setRankUser(converter.fromLeaderBoardEntry(userRank));

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

@@ -11,17 +11,14 @@ 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 dev.sheldan.abstracto.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 @Component
 @Slf4j
@@ -30,31 +27,21 @@ public class SetExpRole extends AbstractConditionableCommand {
     @Autowired
     private ExperienceRoleService experienceRoleService;
 
-    @Autowired
-    private RoleManagementService roleManagementService;
-
     @Autowired
     private RoleService roleService;
 
-    @Autowired
-    private TemplateService templateService;
-
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         Integer level = (Integer) commandContext.getParameters().getParameters().get(0);
-        Long roleId = (Long) commandContext.getParameters().getParameters().get(1);
-        Optional<ARole> roleOpt = roleManagementService.findRole(roleId, commandContext.getUserInitiatedContext().getServer());
-        if(roleOpt.isPresent()) {
-            ARole role = roleOpt.get();
-            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 {}", roleId, level, server.getId());
-            experienceRoleService.setRoleToLevel(role, level, server, commandContext.getUserInitiatedContext().getChannel());
-            return CommandResult.fromSuccess();
+        ARole role = (ARole) commandContext.getParameters().getParameters().get(1);
+        AServer server = commandContext.getUserInitiatedContext().getServer();
+        if(!roleService.isRoleInServer(role)) {
+            throw new RoleNotFoundInGuildException(role.getId(), server.getId());
         }
-       return CommandResult.fromError(templateService.renderTemplate("could_not_find_role", new Object()));
+        log.info("Setting role  {} to be used for level {} on server {}", role.getId(), level, server.getId());
+        experienceRoleService.setRoleToLevel(role, level, commandContext.getUserInitiatedContext().getChannel());
+        return CommandResult.fromSuccess();
     }
 
     @Override

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

@@ -8,7 +8,6 @@ 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;
@@ -20,18 +19,16 @@ import java.util.List;
 @Component
 public class UnSetExpRole extends AbstractConditionableCommand {
 
-    @Autowired
-    private RoleManagementService roleManagementService;
-
     @Autowired
     private ExperienceRoleService experienceRoleService;
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
+        checkParameters(commandContext);
         ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
         // 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
-        experienceRoleService.unsetRole(role, commandContext.getUserInitiatedContext().getServer(), commandContext.getUserInitiatedContext().getChannel());
+        experienceRoleService.unsetRole(role, commandContext.getUserInitiatedContext().getChannel());
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/config/ExperienceConfig.java

@@ -23,7 +23,7 @@ public class ExperienceConfig {
     /**
      * The default multiplier from the properties file. This is used, when the bot joins a new guild.
      */
-    private Integer expMultiplier;
+    private Double expMultiplier;
 
     /**
      * The defaul maxLevel from the properties file. This configuration applies globally, as the amount of levels does not depend on the server.

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/config/ExperienceConfigListener.java

@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.experience.config;
 import dev.sheldan.abstracto.core.listener.ServerConfigListener;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
+import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -24,8 +25,8 @@ public class ExperienceConfigListener implements ServerConfigListener {
     @Override
     public void updateServerConfig(AServer server) {
         log.info("Setting up experience configuration for server {}.", server.getId());
-        service.createIfNotExists(server.getId(), "minExp", experienceConfig.getMinExp().longValue());
-        service.createIfNotExists(server.getId(), "maxExp", experienceConfig.getMaxExp().longValue());
-        service.createIfNotExists(server.getId(), "expMultiplier", experienceConfig.getExpMultiplier().doubleValue());
+        service.createIfNotExists(server.getId(), ExperienceFeatureConfig.MIN_EXP_KEY, experienceConfig.getMinExp().longValue());
+        service.createIfNotExists(server.getId(), ExperienceFeatureConfig.MAX_EXP_KEY, experienceConfig.getMaxExp().longValue());
+        service.createIfNotExists(server.getId(), ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, experienceConfig.getExpMultiplier());
     }
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/config/ExperienceDefaultConfigListener.java

@@ -1,12 +1,14 @@
 package dev.sheldan.abstracto.experience.config;
 
 import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
+import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.event.ContextRefreshedEvent;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+
 @Component
 public class ExperienceDefaultConfigListener {
 
@@ -19,8 +21,8 @@ public class ExperienceDefaultConfigListener {
     @EventListener
     @Transactional
     public void handleContextRefreshEvent(ContextRefreshedEvent ctxStartEvt) {
-        defaultConfigManagementService.createDefaultConfig("minExp", experienceConfig.getMinExp().longValue());
-        defaultConfigManagementService.createDefaultConfig("maxExp", experienceConfig.getMaxExp().longValue());
-        defaultConfigManagementService.createDefaultConfig("expMultiplier", experienceConfig.getExpMultiplier().doubleValue());
+        defaultConfigManagementService.createDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY, experienceConfig.getMinExp().longValue());
+        defaultConfigManagementService.createDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY, experienceConfig.getMaxExp().longValue());
+        defaultConfigManagementService.createDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, experienceConfig.getExpMultiplier());
     }
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/job/ExperiencePersistingJob.java

@@ -12,7 +12,7 @@ import org.springframework.scheduling.quartz.QuartzJobBean;
 import org.springframework.stereotype.Component;
 
 import java.time.Instant;
-import java.util.HashMap;
+import java.util.Map;
 import java.util.List;
 
 
@@ -32,7 +32,7 @@ public class ExperiencePersistingJob extends QuartzJobBean {
 
     @Override
     protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
-        HashMap<Long, List<AServer>> runtimeExperience = userExperienceService.getRuntimeExperience();
+        Map<Long, List<AServer>> runtimeExperience = userExperienceService.getRuntimeExperience();
         log.info("Running experience persisting job.");
         Long pastMinute = (Instant.now().getEpochSecond() / 60) - 1;
         if(runtimeExperience.containsKey(pastMinute)) {

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/repository/ExperienceRoleRepository.java

@@ -18,12 +18,11 @@ import java.util.List;
 public interface ExperienceRoleRepository extends JpaRepository<AExperienceRole, Long> {
     /**
      * Finds the {@link AExperienceRole} of the given {@link AServer} and {@link ARole}
-     * @param server The {@link AServer} to retrieve the {@link AExperienceRole} for
      * @param role The {@link ARole} to filter for
      * @return The {@link AExperienceRole} found or null if the query did not return any results
      */
     @QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
-    AExperienceRole findByRoleServerAndRole(AServer server, ARole role);
+    AExperienceRole findByRole(ARole role);
 
     /**
      * Finds a list of {@link AExperienceRole} (if there are multiple ones, because of misconfiguration) of the given

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

@@ -1,6 +1,5 @@
 package dev.sheldan.abstracto.experience.service;
 
-import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
@@ -9,6 +8,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.experience.config.features.ExperienceFeatureConfig;
 import dev.sheldan.abstracto.experience.models.database.*;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
@@ -36,7 +36,6 @@ import java.util.stream.Collectors;
 @Slf4j
 public class AUserExperienceServiceBean implements AUserExperienceService {
 
-    private HashMap<Long, List<AServer>> runtimeExperience = new HashMap<>();
 
     @Autowired
     private UserExperienceManagementService userExperienceManagementService;
@@ -68,6 +67,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Autowired
     private BotService botService;
 
+    @Autowired
+    private RunTimeExperienceService runTimeExperienceService;
+
     /**
      * Creates the user in the runtime experience, if the user was not in yet. Also creates an entry for the minute, if necessary.
      * @param userInAServer The {@link AUserInAServer} to be added to the list of users gaining experience
@@ -75,6 +77,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Override
     public void addExperience(AUserInAServer userInAServer) {
         Long second = Instant.now().getEpochSecond() / 60;
+        Map<Long, List<AServer>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
         if(runtimeExperience.containsKey(second)) {
             List<AServer> existing = runtimeExperience.get(second);
             existing.forEach(server -> {
@@ -94,39 +97,40 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     }
 
     @Override
-    public HashMap<Long, List<AServer>> getRuntimeExperience() {
-        return runtimeExperience;
+    public Map<Long, List<AServer>> getRuntimeExperience() {
+        return runTimeExperienceService.getRuntimeExperience();
     }
 
+
     /**
      * Calculates the level of the given {@link AUserExperience} accoring to the given {@link AExperienceLevel} list
      * @param experience The {@link AUserExperience} to calculate the level for
-     * @param levels The list of {@link AExperienceLevel} representing the level configuration
+     * @param levels The list of {@link AExperienceLevel} representing the level configuration, this must include the initial level 0
+     *      *               This level will be taken as the initial value, and if no other level qualifies, this will be taken.
+     *               The levels must be ordered.
      * @return The appropriate level according to the level config
      */
     @Override
-    public Integer calculateLevel(AUserExperience experience, List<AExperienceLevel> levels) {
+    public AExperienceLevel calculateLevel(AUserExperience experience, List<AExperienceLevel> levels) {
         AExperienceLevel lastLevel = levels.get(0);
         for (AExperienceLevel level : levels) {
             if(level.getExperienceNeeded() >= experience.getExperience()) {
-                return lastLevel.getLevel();
+                return lastLevel;
             } else {
                 lastLevel = level;
             }
         }
-        return lastLevel.getLevel();
+        return lastLevel;
     }
 
     @Override
-    public boolean updateUserlevel(AUserExperience userExperience, List<AExperienceLevel> levels) {
+    public boolean updateUserLevel(AUserExperience userExperience, List<AExperienceLevel> levels) {
         AUserInAServer user = userExperience.getUser();
-        Integer correctLevel = calculateLevel(userExperience, levels);
+        AExperienceLevel correctLevel = calculateLevel(userExperience, levels);
         Integer currentLevel = userExperience.getCurrentLevel() != null ? userExperience.getCurrentLevel().getLevel() : 0;
-        if(!correctLevel.equals(currentLevel)) {
-            log.info("User {} leveled from {} to {}", user.getUserReference().getId(), currentLevel, correctLevel);
-            AExperienceLevel currentLevel1 = experienceLevelManagementService.getLevel(correctLevel)
-                    .orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", correctLevel)));
-            userExperience.setCurrentLevel(currentLevel1);
+        if(!correctLevel.getLevel().equals(currentLevel)) {
+            log.info("User {} leveled from {} to {}", user.getUserReference().getId(), currentLevel, correctLevel.getLevel());
+            userExperience.setCurrentLevel(correctLevel);
             return true;
         }
         return false;
@@ -145,9 +149,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     public void handleExperienceGain(List<AServer> servers) {
         servers.forEach(serverExp -> {
             log.trace("Handling experience for server {}", serverExp.getId());
-            int minExp = configService.getLongValue("minExp", serverExp.getId()).intValue();
-            int maxExp = configService.getLongValue("maxExp", serverExp.getId()).intValue();
-            Double multiplier = configService.getDoubleValue("expMultiplier", serverExp.getId());
+            int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getId()).intValue();
+            int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getId()).intValue();
+            Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getId());
             PrimitiveIterator.OfInt iterator = new Random().ints(serverExp.getUsers().size(), minExp, maxExp + 1).iterator();
             List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
             levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
@@ -163,7 +167,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                     log.trace("Handling {}. The user gains {}", userInAServer.getUserReference().getId(), gainedExperience);
                     AUserExperience aUserExperience = userExperienceManagementService.incrementExpForUser(userInAServer, gainedExperience.longValue(), 1L);
                     if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
-                        updateUserlevel(aUserExperience, levels);
+                        updateUserLevel(aUserExperience, levels);
                         updateUserRole(aUserExperience, roles);
                         userExperienceManagementService.saveUser(aUserExperience);
                     } else {
@@ -299,11 +303,16 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
      */
     @Override
     public LeaderBoard findLeaderBoardData(AServer server, Integer page) {
-        List<AUserExperience> experiences = userExperienceManagementService.findLeaderboardUsersPaginated(server, page * 10, (page +1) * 10);
+        if(page <= 0) {
+            throw new IllegalArgumentException("Page needs to be >= 1");
+        }
+        page--;
+        int pageSize = 10;
+        List<AUserExperience> experiences = userExperienceManagementService.findLeaderboardUsersPaginated(server, page * pageSize, (page + 1) * pageSize);
         List<LeaderBoardEntry> entries = new ArrayList<>();
         for (int i = 0; i < experiences.size(); i++) {
             AUserExperience userExperience = experiences.get(i);
-            entries.add(LeaderBoardEntry.builder().experience(userExperience).rank(i + 1).build());
+            entries.add(LeaderBoardEntry.builder().experience(userExperience).rank((page * pageSize) + i + 1).build());
         }
         return LeaderBoard.builder().entries(entries).build();
     }
@@ -316,19 +325,15 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Override
     public LeaderBoardEntry getRankOfUserInServer(AUserInAServer userInAServer) {
         log.info("Retrieving rank for {}", userInAServer.getUserReference().getId());
-        AUserExperience experience = userExperienceManagementService.findUserInServer(userInAServer);
-        LeaderBoardEntryResult rankOfUserInServer = userExperienceManagementService.getRankOfUserInServer(experience);
-        AExperienceLevel currentLevel = experienceLevelManagementService.getLevel(rankOfUserInServer.getLevel())
-                .orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", rankOfUserInServer.getLevel())));
-        AUserExperience aUserExperience = AUserExperience
-                .builder()
-                .experience(rankOfUserInServer.getExperience())
-                .user(userInAServer)
-                .messageCount(rankOfUserInServer.getMessageCount())
-                .id(userInAServer.getUserInServerId())
-                .currentLevel(currentLevel)
-                .build();
-        return LeaderBoardEntry.builder().experience(aUserExperience).rank(rankOfUserInServer.getRank()).build();
+        AUserExperience aUserExperience = userExperienceManagementService.findUserInServer(userInAServer);
+        Integer rank = 0;
+        if(aUserExperience != null) {
+            LeaderBoardEntryResult rankOfUserInServer = userExperienceManagementService.getRankOfUserInServer(aUserExperience);
+            if(rankOfUserInServer != null) {
+                rank = rankOfUserInServer.getRank();
+            }
+        }
+        return LeaderBoardEntry.builder().experience(aUserExperience).rank(rank).build();
     }
 
 }

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

@@ -41,7 +41,10 @@ public class ExperienceLevelServiceBean implements ExperienceLevelService {
      * @param level The level to calculate the experience amount for
      * @return The needed experience to reach this level, if the user already has the level below the passed one
      */
-    private Long calculateExperienceForLevel(Integer level) {
+    public Long calculateExperienceForLevel(Integer level) {
+        if(level < 0) {
+            throw new IllegalArgumentException("Level should not be less to 0.");
+        }
         return 5L * (level * level) + 50 * level + 100;
     }
 

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

@@ -1,6 +1,5 @@
 package dev.sheldan.abstracto.experience.service;
 
-import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
@@ -35,14 +34,13 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
      * in the given {@link AServer}
      * @param role The {@link ARole} to set the level to
      * @param level The level the {@link ARole} should be awareded at
-     * @param server The {@link AServer} for which this configuration should be done
      */
     @Override
-    public void setRoleToLevel(ARole role, Integer level, AServer server, AChannel feedbackChannel) {
-        AExperienceLevel experienceLevel = experienceLevelService.getLevel(level).orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", level)));
-        unsetRole(role, server, feedbackChannel);
-        experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServer(experienceLevel, server);
-        experienceRoleManagementService.setLevelToRole(experienceLevel, role, server);
+    public void setRoleToLevel(ARole role, Integer level, AChannel feedbackChannel) {
+        AExperienceLevel experienceLevel = experienceLevelService.getLevel(level).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find level %s", level)));
+        unsetRole(role, feedbackChannel);
+        experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServer(experienceLevel, role.getServer());
+        experienceRoleManagementService.setLevelToRole(experienceLevel, role);
     }
 
     /**
@@ -50,15 +48,14 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
      * {@link net.dv8tion.jda.api.entities.Role}.
      * @param role The {@link ARole} to remove from the {@link dev.sheldan.abstracto.experience.models.database.AExperienceRole}
      *             configuration
-     * @param server The {@link AServer} for which the {@link ARole} should be removed from the configuration
      */
     @Override
-    public void unsetRole(ARole role, AServer server, AChannel feedbackChannel) {
-        AExperienceRole roleInServer = experienceRoleManagementService.getRoleInServer(role, server);
+    public void unsetRole(ARole role, AChannel feedbackChannel) {
+        AExperienceRole roleInServer = experienceRoleManagementService.getRoleInServer(role);
         if(roleInServer != null) {
             if(!roleInServer.getUsers().isEmpty()) {
                 log.info("Recalculating the roles for {} users, because their current role was removed from experience tracking.", roleInServer.getUsers().size());
-                List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
+                List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(role.getServer());
                 roles.removeIf(role1 -> role1.getId().equals(roleInServer.getId()));
 
                 userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), feedbackChannel,
@@ -93,7 +90,7 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
     @Override
     public AExperienceLevel getLevelOfNextRole(AExperienceLevel startLevel, AServer server) {
         List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
-        roles = roles.stream().filter(role -> role.getLevel().getLevel() < startLevel.getLevel()).collect(Collectors.toList());
+        roles = roles.stream().filter(role -> role.getLevel().getLevel() > startLevel.getLevel()).collect(Collectors.toList());
         roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
         AExperienceRole aExperienceRole = roles.stream().findFirst().orElse(null);
         return aExperienceRole != null ? aExperienceRole.getLevel() : AExperienceLevel.builder().level(200).build();

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

@@ -0,0 +1,18 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class RunTimeExperienceService {
+    private Map<Long, List<AServer>> runtimeExperience = new HashMap<>();
+
+    public Map<Long, List<AServer>> getRuntimeExperience() {
+        return runtimeExperience;
+    }
+
+}

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

@@ -22,8 +22,7 @@ public class DisabledExpRoleManagementServiceBean implements DisabledExpRoleMana
                 .role(role)
                 .build();
 
-        disabledExpRoleRepository.save(newRole);
-        return newRole;
+        return disabledExpRoleRepository.save(newRole);
     }
 
     @Override

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

@@ -21,8 +21,7 @@ public class ExperienceLevelManagementServiceBean implements ExperienceLevelMana
                 .experienceNeeded(neededExperience)
                 .level(level)
                 .build();
-        experienceLevelRepository.save(experienceLevel);
-        return experienceLevel;
+        return experienceLevelRepository.save(experienceLevel);
     }
 
     @Override

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

@@ -36,8 +36,8 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
     }
 
     @Override
-    public AExperienceRole getRoleInServer(ARole role, AServer server) {
-        return experienceRoleRepository.findByRoleServerAndRole(server, role);
+    public AExperienceRole getRoleInServer(ARole role) {
+        return experienceRoleRepository.findByRole(role);
     }
 
     @Override
@@ -46,18 +46,19 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
     }
 
     @Override
-    public void setLevelToRole(AExperienceLevel level, ARole role, AServer server) {
-        AExperienceRole byRoleServerAndRole = experienceRoleRepository.findByRoleServerAndRole(server, role);
+    public AExperienceRole setLevelToRole(AExperienceLevel level, ARole role) {
+        AExperienceRole byRoleServerAndRole = experienceRoleRepository.findByRole(role);
         if(byRoleServerAndRole != null) {
             byRoleServerAndRole.setLevel(level);
         } else {
             byRoleServerAndRole = AExperienceRole
                     .builder()
                     .level(level)
-                    .roleServer(server)
+                    .roleServer(role.getServer())
                     .role(role)
                     .build();
+            byRoleServerAndRole = experienceRoleRepository.save(byRoleServerAndRole);
         }
-        experienceRoleRepository.save(byRoleServerAndRole);
+        return byRoleServerAndRole;
     }
 }

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

@@ -90,8 +90,8 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
     }
 
     @Override
-    public void saveUser(AUserExperience userExperience) {
-        repository.save(userExperience);
+    public AUserExperience saveUser(AUserExperience userExperience) {
+        return repository.save(userExperience);
     }
 }
 

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

@@ -0,0 +1,59 @@
+package dev.sheldan.abstracto.experience;
+
+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.experience.models.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
+import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import dev.sheldan.abstracto.test.MockUtils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+
+public abstract class ExperienceRelatedTest {
+
+    protected List<AUserExperience> getUserExperiences(int count, AServer server) {
+        List<AUserExperience> experiences = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            experiences.add(getUserExperienceObject(server, i));
+        }
+        return experiences;
+    }
+
+    protected AUserExperience getUserExperienceObject(AServer server, int i) {
+        AUserInAServer userObject = MockUtils.getUserObject((long)i, server);
+        AExperienceLevel level = AExperienceLevel
+                .builder()
+                .level(i)
+                .experienceNeeded((long) i * 100)
+                .build();
+        return AUserExperience
+                .builder()
+                .user(userObject)
+                .experience((long) i)
+                .currentLevel(level)
+                .build();
+    }
+
+    protected List<AExperienceLevel> getLevelConfiguration() {
+        AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(0L).level(0).build();
+        AExperienceLevel level1 = AExperienceLevel.builder().experienceNeeded(100L).level(1).build();
+        AExperienceLevel level2 = AExperienceLevel.builder().experienceNeeded(200L).level(2).build();
+        AExperienceLevel level3 = AExperienceLevel.builder().experienceNeeded(300L).level(3).build();
+        return new ArrayList<>(Arrays.asList(level0, level1, level2, level3));
+    }
+
+    protected List<AExperienceRole> getExperienceRoles(List<AExperienceLevel> levelsWithRoles, AServer server) {
+        List<AExperienceRole> roles = new ArrayList<>();
+        for (int i = 0; i < levelsWithRoles.size(); i++) {
+            AExperienceLevel level = levelsWithRoles.get(i);
+            ARole role = ARole.builder().id((long)i).server(server).build();
+            roles.add(AExperienceRole.builder().level(level).roleServer(server).role(role).build());
+        }
+        return roles;
+    }
+
+}

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

@@ -0,0 +1,62 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+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.experience.service.management.DisabledExpRoleManagementService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DisableExpForRoleTest {
+
+    @InjectMocks
+    private DisableExpForRole testUnit;
+
+    @Mock
+    private DisabledExpRoleManagementService disabledExpRoleManagementService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void testExecuteCommandForNotDisabledRole() {
+        executeDisableExpForRoleTest(false, 1);
+    }
+
+    @Test
+    public void testExecuteCommandForDisabledRole() {
+        executeDisableExpForRoleTest(true, 0);
+    }
+
+    private void executeDisableExpForRoleTest(boolean value, int wantedNumberOfInvocations) {
+        ARole disabledRole = MockUtils.getRole(1L, MockUtils.getServer());
+        CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(disabledRole));
+        when(disabledExpRoleManagementService.isExperienceDisabledForRole(disabledRole)).thenReturn(value);
+        CommandResult result = testUnit.execute(context);
+        verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).setRoleToBeDisabledForExp(disabledRole);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+}

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

@@ -0,0 +1,61 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+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.management.UserInServerManagementService;
+import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DisableExpGainTest {
+
+    @InjectMocks
+    private DisableExpGain testUnit;
+
+    @Mock
+    private AUserExperienceService aUserExperienceService;
+
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void testDisableExpForMember() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
+        AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
+        Member member = MockUtils.getMockedMember(noParameters.getUserInitiatedContext().getServer(), parameterUser, jda);
+        CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
+        when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);
+        CommandResult result = testUnit.execute(context);
+        verify(aUserExperienceService, times(1)).disableExperienceForUser(parameterUser);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+
+}

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

@@ -0,0 +1,62 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+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.experience.service.management.DisabledExpRoleManagementService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EnableExpForRoleTest {
+
+    @InjectMocks
+    private EnableExpForRole testUnit;
+
+    @Mock
+    private DisabledExpRoleManagementService disabledExpRoleManagementService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void testExecuteCommandForNotDisabledRole() {
+        executeEnableExpForRoleTest(false, 0);
+    }
+
+    @Test
+    public void testExecuteCommandForDisabledRole() {
+        executeEnableExpForRoleTest(true, 1);
+    }
+
+    private void executeEnableExpForRoleTest(boolean value, int wantedNumberOfInvocations) {
+        ARole disabledRole = MockUtils.getRole(1L, MockUtils.getServer());
+        CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(disabledRole));
+        when(disabledExpRoleManagementService.isExperienceDisabledForRole(disabledRole)).thenReturn(value);
+        CommandResult result = testUnit.execute(context);
+        verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).removeRoleToBeDisabledForExp(disabledRole);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+}

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

@@ -0,0 +1,61 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+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.management.UserInServerManagementService;
+import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EnableExpGainTest {
+
+    @InjectMocks
+    private EnableExpGain testUnit;
+
+    @Mock
+    private AUserExperienceService aUserExperienceService;
+
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void testEnableExpForMember() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
+        AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
+        Member member = MockUtils.getMockedMember(noParameters.getUserInitiatedContext().getServer(), parameterUser, jda);
+        CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
+        when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);
+        CommandResult result = testUnit.execute(context);
+        verify(aUserExperienceService, times(1)).enableExperienceForUser(parameterUser);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+
+}

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

@@ -0,0 +1,51 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExpScaleTest {
+
+    @InjectMocks
+    private ExpScale testUnit;
+
+    @Mock
+    private ConfigService configService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void testSetExpScaleForGuild() {
+        double newScale = 4.5;
+        CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(newScale));
+        CommandResult result = testUnit.execute(context);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(configService, times(1)).setDoubleValue(ExpScale.EXP_MULTIPLIER_KEY, context.getGuild().getIdLong(), newScale);
+
+    }
+}

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

@@ -0,0 +1,78 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+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;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LeaderBoardCommandTest {
+
+    @InjectMocks
+    private LeaderBoardCommand testUnit;
+
+    @Mock
+    private AUserExperienceService userExperienceService;
+
+    @Mock
+    private TemplateService templateService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private LeaderBoardModelConverter converter;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void testLeaderBoardWithNoParameter() {
+        testLeaderBoardCommand(CommandTestUtilities.getNoParameters(jda), 1);
+    }
+
+    @Test
+    public void testLeaderBoardWithPageParameter() {
+        testLeaderBoardCommand(CommandTestUtilities.getWithParameters(jda, Arrays.asList(5)), 5);
+    }
+
+    private void testLeaderBoardCommand(CommandContext context, int expectedPage) {
+        LeaderBoard leaderBoard = LeaderBoard.builder().build();
+        when(userExperienceService.findLeaderBoardData(context.getUserInitiatedContext().getServer(), expectedPage)).thenReturn(leaderBoard);
+        when(converter.fromLeaderBoard(leaderBoard)).thenReturn(new ArrayList<>());
+        LeaderBoardEntry executingUserRank = LeaderBoardEntry.builder().build();
+        when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(executingUserRank);
+        LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
+        when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(leaderBoardEntryModel);
+        MessageToSend messageToSend = MessageToSend.builder().build();
+        when(templateService.renderEmbedTemplate(eq(LeaderBoardCommand.LEADERBOARD_POST_EMBED_TEMPLATE), any(LeaderBoardModel.class))).thenReturn(messageToSend);
+        CommandResult result = testUnit.execute(context);
+        verify(channelService, times(1)).sendMessageToSendToChannel(messageToSend, context.getChannel());
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+}

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

@@ -0,0 +1,69 @@
+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.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.experience.models.database.ADisabledExpRole;
+import dev.sheldan.abstracto.experience.models.templates.DisabledExperienceRolesModel;
+import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ListDisabledExperienceRolesTest {
+
+    @InjectMocks
+    private ListDisabledExperienceRoles testUnit;
+
+    @Mock
+    private DisabledExpRoleManagementService disabledExpRoleManagementService;
+
+    @Mock
+    private RoleService roleService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test
+    public void testCommandExecutionNoRolesFound() {
+        CommandContext context = CommandTestUtilities.getNoParameters(jda);
+        AServer server = context.getUserInitiatedContext().getServer();
+        when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
+        CommandResult result = testUnit.execute(context);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(roleService, times(0)).getRoleFromGuild(any(ARole.class));
+        verify(channelService, times(1)).sendEmbedTemplateInChannel(eq("list_disabled_experience_roles"),
+                any(DisabledExperienceRolesModel.class), eq(context.getChannel()));
+    }
+
+    @Test
+    public void testCommandExecutionRolesFound() {
+        CommandContext context = CommandTestUtilities.getNoParameters(jda);
+        AServer server = context.getUserInitiatedContext().getServer();
+        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));
+        CommandResult result = testUnit.execute(context);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(roleService, times(2)).getRoleFromGuild(any(ARole.class));
+        verify(channelService, times(1)).sendEmbedTemplateInChannel(eq("list_disabled_experience_roles"),
+                any(DisabledExperienceRolesModel.class), eq(context.getChannel()));
+    }
+}

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

@@ -0,0 +1,69 @@
+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.service.ChannelService;
+import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
+import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
+import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
+import 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.templating.model.MessageToSend;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RankTest {
+
+    @InjectMocks
+    private Rank testUnit;
+
+    @Mock
+    private LeaderBoardModelConverter converter;
+
+    @Mock
+    private TemplateService templateService;
+
+    @Mock
+    private AUserExperienceService userExperienceService;
+
+    @Mock
+    private ExperienceLevelService experienceLevelService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test
+    public void testRankExecution() {
+        int currentLevelValue = 50;
+        long currentExperience = 50L;
+        CommandContext context = CommandTestUtilities.getNoParameters(jda);
+        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);
+        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);
+        CommandResult result = testUnit.execute(context);
+        verify(channelService, Mockito.times(1)).sendMessageToSendToChannel(messageToSend, context.getChannel());
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+}

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

@@ -0,0 +1,82 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+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.experience.service.ExperienceRoleService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SetExpRoleTest {
+
+    @InjectMocks
+    private SetExpRole testUnit;
+
+    @Mock
+    private ExperienceRoleService experienceRoleService;
+
+    @Mock
+    private RoleService roleService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = InsufficientParameters.class)
+    public void testRoleMissing() {
+        CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(4));
+        testUnit.execute(context);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testLevelProvidedButNotRole() {
+        CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(4, ""));
+        testUnit.execute(context);
+    }
+
+    @Test
+    public void setExpRole() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
+        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(true);
+        CommandResult result = testUnit.execute(context);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(experienceRoleService, times(1)).setRoleToLevel(changedRole, levelToSetTo, context.getUserInitiatedContext().getChannel());
+    }
+
+    @Test(expected = RoleNotFoundInGuildException.class)
+    public void setExpRoleNotExistingOnServer() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
+        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.execute(context);
+    }
+}

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

@@ -0,0 +1,39 @@
+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.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SyncRolesTest {
+
+    @InjectMocks
+    private SyncRoles testUnit;
+
+    @Mock
+    private AUserExperienceService userExperienceService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test
+    public void executeCommand() {
+        CommandContext context = CommandTestUtilities.getNoParameters(jda);
+        CommandResult result = testUnit.execute(context);
+        AServer server = context.getUserInitiatedContext().getServer();
+        AChannel channel = context.getUserInitiatedContext().getChannel();
+        verify(userExperienceService, times(1)).syncUserRolesWithFeedback(server, channel);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+    }
+}

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

@@ -0,0 +1,54 @@
+package dev.sheldan.abstracto.experience.commands;
+
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
+import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
+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.experience.service.ExperienceRoleService;
+import dev.sheldan.abstracto.test.MockUtils;
+import dev.sheldan.abstracto.test.command.CommandTestUtilities;
+import net.dv8tion.jda.internal.JDAImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UnSetExpRoleTest {
+
+    @InjectMocks
+    private UnSetExpRole testUnit;
+
+    @Mock
+    private ExperienceRoleService experienceRoleService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test(expected = InsufficientParameters.class)
+    public void testTooLittleParameters() {
+        CommandTestUtilities.executeNoParametersTest(testUnit, jda);
+    }
+
+    @Test(expected = IncorrectParameter.class)
+    public void testIncorrectParameterType() {
+        CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
+    }
+
+    @Test
+    public void setUnSetExpRole() {
+        CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
+        ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
+        CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(changedRole));
+        CommandResult result = testUnit.execute(context);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(experienceRoleService, times(1)).unsetRole(changedRole, context.getUserInitiatedContext().getChannel());
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/config/ExperienceConfigListenerTest.java

@@ -0,0 +1,57 @@
+package dev.sheldan.abstracto.experience.config;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
+import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
+import dev.sheldan.abstracto.test.MockUtils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExperienceConfigListenerTest {
+
+    @InjectMocks
+    private ExperienceConfigListener testUnit;
+
+    @Mock
+    private ExperienceConfig experienceConfig;
+
+    @Mock
+    private ConfigManagementService service;
+
+    @Captor
+    private ArgumentCaptor<Long> configValueCaptor;
+
+    @Captor
+    private ArgumentCaptor<String> configKeyCaptor;
+
+    @Test
+    public void setSettingUp() {
+        int minExp = 4;
+        int maxExp = 10;
+        double expMultiplier = 2;
+        when(experienceConfig.getMinExp()).thenReturn(minExp);
+        when(experienceConfig.getMaxExp()).thenReturn(maxExp);
+        when(experienceConfig.getExpMultiplier()).thenReturn(expMultiplier);
+        AServer server = MockUtils.getServer();
+        testUnit.updateServerConfig(server);
+        verify(service, times(2)).createIfNotExists(eq(server.getId()), configKeyCaptor.capture(), configValueCaptor.capture());
+        verify(service, times(1)).createIfNotExists(server.getId(), ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, expMultiplier);
+        List<String> configKeys = configKeyCaptor.getAllValues();
+        List<Long> configValues = configValueCaptor.getAllValues();
+        Assert.assertEquals(ExperienceFeatureConfig.MIN_EXP_KEY, configKeys.get(0));
+        Assert.assertEquals(minExp, configValues.get(0).intValue());
+        Assert.assertEquals(ExperienceFeatureConfig.MAX_EXP_KEY, configKeys.get(1));
+        Assert.assertEquals(maxExp, configValues.get(1).intValue());
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/config/ExperienceDefaultConfigListenerTest.java

@@ -0,0 +1,54 @@
+package dev.sheldan.abstracto.experience.config;
+
+import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
+import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExperienceDefaultConfigListenerTest {
+
+    @InjectMocks
+    private ExperienceDefaultConfigListener testUnit;
+
+    @Mock
+    private ExperienceConfig experienceConfig;
+
+    @Mock
+    private DefaultConfigManagementService service;
+
+    @Captor
+    private ArgumentCaptor<Long> configValueCaptor;
+
+    @Captor
+    private ArgumentCaptor<String> configKeyCaptor;
+
+    @Test
+    public void setSettingUp() {
+        int minExp = 4;
+        int maxExp = 10;
+        double expMultiplier = 2;
+        when(experienceConfig.getMinExp()).thenReturn(minExp);
+        when(experienceConfig.getMaxExp()).thenReturn(maxExp);
+        when(experienceConfig.getExpMultiplier()).thenReturn(expMultiplier);
+        testUnit.handleContextRefreshEvent(null);
+        verify(service, times(2)).createDefaultConfig(configKeyCaptor.capture(), configValueCaptor.capture());
+        verify(service, times(1)).createDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, expMultiplier);
+        List<String> configKeys = configKeyCaptor.getAllValues();
+        List<Long> configValues = configValueCaptor.getAllValues();
+        Assert.assertEquals(ExperienceFeatureConfig.MIN_EXP_KEY, configKeys.get(0));
+        Assert.assertEquals(minExp, configValues.get(0).intValue());
+        Assert.assertEquals(ExperienceFeatureConfig.MAX_EXP_KEY, configKeys.get(1));
+        Assert.assertEquals(maxExp, configValues.get(1).intValue());
+    }
+}

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

@@ -0,0 +1,75 @@
+package dev.sheldan.abstracto.experience.converter;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.models.LeaderBoard;
+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.test.MockUtils;
+import net.dv8tion.jda.internal.JDAImpl;
+import net.dv8tion.jda.internal.entities.MemberImpl;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    public LeaderBoardModelConverter testUnit;
+
+    @Mock
+    private BotService botService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test
+    public void testFromLeaderBoard() {
+        AServer server = MockUtils.getServer();
+        int firstRank = 1;
+        int firstExperience = 1;
+        LeaderBoardEntry entry = getEntry(server, firstExperience, firstRank);
+        int secondRank = 2;
+        int secondExperience = 2;
+        LeaderBoardEntry entry2 = getEntry(server, secondExperience, secondRank);
+        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);
+        Assert.assertEquals(firstRank, firstEntry.getRank().intValue());
+        Assert.assertEquals(firstExperience, firstEntry.getExperience().getExperience().longValue());
+        LeaderBoardEntryModel secondEntry = leaderBoardEntryModels.get(1);
+        Assert.assertEquals(secondRank, secondEntry.getRank().intValue());
+        Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience().longValue());
+        Assert.assertEquals(entries.size(), leaderBoardEntryModels.size());
+    }
+
+    @Test
+    public void testFromEntry() {
+        AServer server = MockUtils.getServer();
+        AUserExperience experience = getUserExperienceObject(server, 3);
+        LeaderBoardEntry entry = LeaderBoardEntry.builder().experience(experience).rank(1).build();
+        MemberImpl member = MockUtils.getMockedMember(server, experience.getUser(), jda);
+        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());
+    }
+
+    private LeaderBoardEntry getEntry(AServer server, Integer experienceParameter, Integer rank) {
+        AUserExperience firstExperience = getUserExperienceObject(server, experienceParameter);
+        return LeaderBoardEntry.builder().rank(rank).experience(firstExperience).build();
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListenerTest.java

@@ -0,0 +1,47 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.test.MockUtils;
+import net.dv8tion.jda.internal.JDAImpl;
+import net.dv8tion.jda.internal.entities.MemberImpl;
+import net.dv8tion.jda.internal.entities.ReceivedMessage;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExperienceTrackerListenerTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    public ExperienceTrackerListener testUnit;
+
+    @Mock
+    private AUserExperienceService userExperienceService;
+
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test
+    public void testExperienceTracking() {
+        AServer server = AServer.builder().id(3L).build();
+        AUser user = AUser.builder().id(4L).build();
+        AUserInAServer userInAServer = AUserInAServer.builder().userReference(user).serverReference(server).build();
+        MemberImpl member = MockUtils.getMockedMember(server, userInAServer, jda);
+        ReceivedMessage mockedMessage = MockUtils.buildMockedMessage(1L, "text", member);
+        when(userInServerManagementService.loadUser(member)).thenReturn(userInAServer);
+        testUnit.execute(mockedMessage);
+        verify(userExperienceService, times(1)).addExperience(userInAServer);
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListenerTest.java

@@ -0,0 +1,63 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
+import dev.sheldan.abstracto.test.MockUtils;
+import net.dv8tion.jda.internal.JDAImpl;
+import net.dv8tion.jda.internal.entities.GuildImpl;
+import net.dv8tion.jda.internal.entities.MemberImpl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class JoiningUserRoleListenerTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    private JoiningUserRoleListener testUnit;
+
+    @Mock
+    private UserExperienceManagementService userExperienceManagementService;
+
+    @Mock
+    private AUserExperienceService userExperienceService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Test
+    public void testUserWithExperienceRejoining() {
+        AServer server = AServer.builder().id(3L).build();
+        AUser user = AUser.builder().id(1L).build();
+        AUserInAServer aUserInAServer = AUserInAServer.builder().userInServerId(2L).userReference(user).build();
+        MemberImpl member = MockUtils.getMockedMember(server, aUserInAServer, jda);
+        GuildImpl guild = MockUtils.getGuild(server, jda);
+        AUserExperience experience = AUserExperience.builder().experience(3L).user(aUserInAServer).build();
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
+        testUnit.execute(member, guild, aUserInAServer);
+        verify(userExperienceService, times(1)).syncForSingleUser(experience);
+    }
+
+    @Test
+    public void testUserWithOutExperienceRejoining() {
+        AServer server = AServer.builder().id(3L).build();
+        AUser user = AUser.builder().id(1L).build();
+        AUserInAServer aUserInAServer = AUserInAServer.builder().userInServerId(2L).userReference(user).build();
+        MemberImpl member = MockUtils.getMockedMember(server, aUserInAServer, jda);
+        GuildImpl guild = MockUtils.getGuild(server, jda);
+        AUserExperience experience = AUserExperience.builder().experience(3L).user(aUserInAServer).build();
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(null);
+        testUnit.execute(member, guild, aUserInAServer);
+        verify(userExperienceService, times(0)).syncForSingleUser(experience);
+    }
+
+}

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

@@ -0,0 +1,662 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
+import dev.sheldan.abstracto.core.models.database.*;
+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.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
+import dev.sheldan.abstracto.experience.models.LeaderBoard;
+import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
+import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
+import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel;
+import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
+import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
+import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
+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.MockUtils;
+import net.dv8tion.jda.internal.JDAImpl;
+import net.dv8tion.jda.internal.entities.*;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+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 {
+
+    @InjectMocks
+    private AUserExperienceServiceBean testUnit;
+
+    @Mock
+    private UserExperienceManagementService userExperienceManagementService;
+
+    @Mock
+    private ExperienceRoleService experienceRoleService;
+
+    @Mock
+    private ExperienceLevelManagementService experienceLevelManagementService;
+
+    @Mock
+    private ExperienceRoleManagementService experienceRoleManagementService;
+
+    @Mock
+    private ConfigService configService;
+
+    @Mock
+    private RoleService roleService;
+
+    @Mock
+    private MessageService messageService;
+
+    @Mock
+    private TemplateService templateService;
+
+    @Mock
+    private DisabledExpRoleManagementService disabledExpRoleManagementService;
+
+    @Mock
+    private BotService botService;
+
+    @Mock
+    private JDAImpl jda;
+
+    @Mock
+    private RunTimeExperienceService runTimeExperienceService;
+
+    @Captor
+    private ArgumentCaptor<AUserExperience> aUserExperienceArgumentCaptor;
+
+    @Test
+    public void testCalculateLevelTooLow() {
+        AUserExperience experienceToCalculate = AUserExperience.builder().experience(50L).build();
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        AExperienceLevel calculatedLevel = testUnit.calculateLevel(experienceToCalculate, levels);
+        Assert.assertEquals(0, calculatedLevel.getLevel().intValue());
+    }
+
+    @Test
+    public void testCalculateLevelBetweenLevels() {
+        AUserExperience experienceToCalculate = AUserExperience.builder().experience(250L).build();
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        AExperienceLevel calculatedLevel = testUnit.calculateLevel(experienceToCalculate, levels);
+        Assert.assertEquals(2, calculatedLevel.getLevel().intValue());
+    }
+
+    @Test
+    public void testCalculateLevelTooHigh() {
+        AUserExperience experienceToCalculate = AUserExperience.builder().experience(500L).build();
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        AExperienceLevel calculatedLevel = testUnit.calculateLevel(experienceToCalculate, levels);
+        Assert.assertEquals(3, calculatedLevel.getLevel().intValue());
+    }
+
+    @Test
+    public void testUpdateUserExperienceLevelChanged() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
+        AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(1)).experience(250L).build();
+        Assert.assertTrue(testUnit.updateUserLevel(experienceToCalculate, levels));
+    }
+
+    @Test
+    public void testUpdateUserExperienceLevelNotChanged() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
+        AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(2)).experience(250L).build();
+        Assert.assertFalse(testUnit.updateUserLevel(experienceToCalculate, levels));
+    }
+
+    @Test
+    public void testGainExpSingleUserLvlUpOneServerWithoutRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        AExperienceRole previousExperienceRole = experienceRoles.get(1);
+        when(botService.isUserInGuild(userToUse)).thenReturn(true);
+        AExperienceRole newAwardedRole = testRoleRelatedScenario(false, levels, servers, serverToUse, experienceRoles, userToUse, previousExperienceRole);
+        verify(roleService, times(1)).addRoleToUser(userToUse, newAwardedRole.getRole());
+        verify(roleService, times(1)).removeRoleFromUser(userToUse, previousExperienceRole.getRole());
+    }
+
+    @Test
+    public void testLevelUpGainingNewRoleButUserAlreadyHasRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        AExperienceRole previousExperienceRole = experienceRoles.get(1);
+        AExperienceRole newAwardedRole = testRoleRelatedScenario(true, levels, servers, serverToUse, experienceRoles, userToUse, previousExperienceRole);
+        verify(roleService, times(0)).addRoleToUser(userToUse, newAwardedRole.getRole());
+        verify(roleService, times(0)).removeRoleFromUser(userToUse, previousExperienceRole.getRole());
+    }
+
+    @Test
+    public void testLevelUpNotGainingNewRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        levels.add(AExperienceLevel.builder().level(4).experienceNeeded(400L).build());
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        AExperienceRole previousExperienceRole = experienceRoles.get(3);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 401L, 3, previousExperienceRole, false);
+
+        AExperienceRole newAwardedRole = experienceRoles.get(3);
+        when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(newAwardedRole);
+        when(roleService.memberHasRole(jdaMember, newAwardedRole.getRole())).thenReturn(true);
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(1)).saveUser(eq(newUserExperience));
+        verify(roleService, times(0)).removeRoleFromUser(userToUse, previousExperienceRole.getRole());
+        verify(roleService, times(0)).addRoleToUser(userToUse, newAwardedRole.getRole());
+        Assert.assertEquals(4, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(3L, newUserExperience.getCurrentExperienceRole().getRole().getId().longValue());
+    }
+
+    @Test
+    public void testHandleExperienceForUserNotLevelingUpWithoutExistingRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 101L, 1, null, false);
+
+        when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(experienceRoles.get(1));
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(1)).saveUser(eq(newUserExperience));
+        Assert.assertEquals(1, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(1L, newUserExperience.getCurrentExperienceRole().getRole().getId().longValue());
+    }
+
+    @Test
+    public void handleExpGainWithTooLittleForRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, null, false);
+
+        when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(null);
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(1)).saveUser(eq(newUserExperience));
+        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertNull(newUserExperience.getCurrentExperienceRole());
+    }
+
+    @Test
+    public void testUserHasExperienceRoleButNotAnymore() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), false);
+
+        when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(null);
+        when(botService.isUserInGuild(userToUse)).thenReturn(true);
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(1)).saveUser(eq(newUserExperience));
+        verify(roleService, times(1)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertNull(newUserExperience.getCurrentExperienceRole());
+    }
+
+    @Test
+    public void testHandleExperienceGainForGainDisabledForUser() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), true);
+
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(0)).saveUser(eq(newUserExperience));
+        verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(experienceRoles.get(0).getRole().getId(), newUserExperience.getCurrentExperienceRole().getRole().getId());
+    }
+
+    @Test
+    public void testHandleExperienceGainForGainDisabledForRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), false);
+        when(botService.getMemberInServer(userToUse)).thenReturn(jdaMember);
+        when(roleService.hasAnyOfTheRoles(eq(jdaMember), anyList())).thenReturn(true);
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(0)).saveUser(eq(newUserExperience));
+        verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(experienceRoles.get(0).getRole().getId(), newUserExperience.getCurrentExperienceRole().getRole().getId());
+    }
+
+    @Test
+    public void testHandleExperienceForUserNotLevelingUpWithExistingRole() {
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getOneServerWithOneUser();
+        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 101L, 1, experienceRoles.get(1), false);
+        when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(experienceRoles.get(1));
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(1)).saveUser(eq(newUserExperience));
+        verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+        Assert.assertEquals(1, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(experienceRoles.get(1).getRole().getId(), newUserExperience.getCurrentExperienceRole().getRole().getId());
+    }
+
+    @Test
+    public void testSingleUserInMultipleServers() {
+        // The user levels in one server, and does not level in another one
+        List<AExperienceLevel> levels = getLevelConfiguration();
+        List<AServer> servers = getServersWithUserExperience();
+        List<AUserExperience> userExperiences = new ArrayList<>();
+        List<List<AExperienceRole>> allExperienceRoles = new ArrayList<>();
+        List<Integer> userLevels = Arrays.asList(1,2);
+        List<Long> userExperienceValues = Arrays.asList(101L,301L);
+        List<Integer> experienceRoleIndices = Arrays.asList(1, 2);
+        for (int i = 0; i < servers.size(); i++) {
+            AServer aServer = servers.get(i);
+            Integer level = userLevels.get(i);
+            Long experienceValues = userExperienceValues.get(i);
+            List<AExperienceRole> experienceRoles = getExperienceRoles(levels, aServer);
+            mockSimpleServer(levels, experienceRoles, aServer);
+            AUserInAServer userToUse = aServer.getUsers().get(0);
+            MemberImpl jdaMember = MockUtils.getMockedMember(aServer, userToUse, jda);
+            when(botService.getMemberInServer(aServer, userToUse.getUserReference())).thenReturn(jdaMember);
+            AExperienceRole role = experienceRoles.get(experienceRoleIndices.get(i));
+            AUserExperience newUserExperience = mockServerWithSingleUser(levels, aServer, experienceValues, level, role, false);
+            when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(role);
+            userExperiences.add(newUserExperience);
+            allExperienceRoles.add(experienceRoles);
+        }
+        testUnit.handleExperienceGain(servers);
+        List<Integer> newLevels = Arrays.asList(1,3);
+        List<Integer> newExperienceRoleIndices = Arrays.asList(1, 2);
+        for (int i = 0; i < servers.size(); i++) {
+            AServer server = servers.get(i);
+            AUserExperience newUserExperience = userExperiences.get(i);
+            AUserInAServer userToUse = server.getUsers().get(0);
+            List<AExperienceRole> experienceRoles = allExperienceRoles.get(i);
+            verify(userExperienceManagementService, times(2)).saveUser(aUserExperienceArgumentCaptor.capture());
+            verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+            verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+            Assert.assertEquals(newLevels.get(i).intValue(), newUserExperience.getCurrentLevel().getLevel().intValue());
+            Assert.assertEquals(experienceRoles.get(newExperienceRoleIndices.get(i)).getRole().getId(), newUserExperience.getCurrentExperienceRole().getRole().getId());
+        }
+    }
+
+    @Test
+    public void testSyncNoRoleUserGettingRole() {
+        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
+        AExperienceRole previousRole = null;
+        AExperienceRole afterRole = usedExperienceRoles.get(0);
+        Integer removals = 0;
+        Integer adds = 1;
+        executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole, removals, adds);
+    }
+
+    @Test
+    public void testSyncUserLosingRole() {
+        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
+        AExperienceRole previousRole = usedExperienceRoles.get(0);
+        AExperienceRole afterRole = null;
+        Integer removals = 1;
+        Integer adds = 0;
+        executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole, removals, adds);
+    }
+
+    @Test
+    public void testSyncUserKeepRole() {
+        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
+        AExperienceRole previousRole = usedExperienceRoles.get(0);
+        AExperienceRole afterRole = usedExperienceRoles.get(0);
+        Integer removals = 0;
+        Integer adds = 0;
+        executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole, removals, adds);
+    }
+
+    @Test
+    public void testSyncUserChangingRole() {
+        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
+        AExperienceRole previousRole = usedExperienceRoles.get(0);
+        AExperienceRole afterRole = usedExperienceRoles.get(1);
+        Integer removals = 1;
+        Integer adds = 1;
+        executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole, removals, adds);
+    }
+
+    @Test
+    public void testDisablingExperienceForUser() {
+        AServer server = MockUtils.getServer(1L);
+        AUserInAServer userObject = MockUtils.getUserObject(2L, server);
+        AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
+        when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
+        testUnit.disableExperienceForUser(userObject);
+        Assert.assertTrue(experience.getExperienceGainDisabled());
+    }
+
+    @Test
+    public void testDisablingExpForUserWhichHasItDisabled() {
+        AServer server = MockUtils.getServer(1L);
+        AUserInAServer userObject = MockUtils.getUserObject(2L, server);
+        AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
+        when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
+        testUnit.disableExperienceForUser(userObject);
+        Assert.assertTrue(experience.getExperienceGainDisabled());
+    }
+
+    @Test
+    public void testEnablingExperienceForEnabledUser() {
+        AServer server = MockUtils.getServer(1L);
+        AUserInAServer userObject = MockUtils.getUserObject(2L, server);
+        AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
+        when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
+        testUnit.enableExperienceForUser(userObject);
+        Assert.assertFalse(experience.getExperienceGainDisabled());
+    }
+
+    @Test
+    public void testEnablingExpForUserWhichHasItDisabled() {
+        AServer server = MockUtils.getServer(1L);
+        AUserInAServer userObject = MockUtils.getUserObject(2L, server);
+        AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
+        when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
+        testUnit.enableExperienceForUser(userObject);
+        Assert.assertFalse(experience.getExperienceGainDisabled());
+    }
+
+    @Test
+    public void testFindLeaderBoardData() {
+        AServer server = MockUtils.getServer(1L);
+        executeLeaderBoardTest(server, 1);
+    }
+
+    @Test
+    public void testFindLeaderBoardDataSecondPage() {
+        AServer server = MockUtils.getServer(1L);
+        executeLeaderBoardTest(server, 2);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIllegalLeaderBoardPage() {
+        testUnit.findLeaderBoardData(MockUtils.getServer(1L), -1);
+    }
+
+    @Test
+    public void testSyncAllUsers() {
+        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
+        AExperienceRole firstPreviousRole = null;
+        AExperienceRole firstAfterRole = usedExperienceRoles.get(0);
+        AExperienceRole secondPreviousRole = null;
+        AExperienceRole secondAfterRole = null;
+        AExperienceLevel level0 = AExperienceLevel.builder().level(0).build();
+        AUserExperience experience = AUserExperience.builder().experience(40L).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
+        AUserExperience experience2 = AUserExperience.builder().experience(201L).user(MockUtils.getUserObject(4L, server)).currentLevel(level0).build();
+        List<AUserExperience> experiences = Arrays.asList(experience, experience2);
+
+        List<AUserInAServer> users = experiences.stream().map(AUserExperience::getUser).collect(Collectors.toList());
+        MemberImpl firstMember = MockUtils.getMockedMember(server, users.get(0), jda);
+        when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(firstMember);
+        MemberImpl secondMember = MockUtils.getMockedMember(server, users.get(1), jda);
+        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(experience, usedExperienceRoles)).thenReturn(firstAfterRole);
+        when(experienceRoleService.calculateRole(experience2, usedExperienceRoles)).thenReturn(secondAfterRole);
+        when(botService.getMemberInServer(server, experience.getUser().getUserReference())).thenReturn(firstMember);
+        when(botService.getMemberInServer(server, experience2.getUser().getUserReference())).thenReturn(secondMember);
+        when(roleService.memberHasRole(firstMember, firstAfterRole.getRole())).thenReturn(false);
+        testUnit.syncUserRoles(server);
+        Assert.assertNull(experience2.getCurrentExperienceRole());
+        Assert.assertEquals(usedExperienceRoles.get(0).getRole().getId(), experience.getCurrentExperienceRole().getRole().getId());
+        verify(roleService, times(1)).addRoleToUser(users.get(0), usedExperienceRoles.get(0).getRole());
+    }
+
+    @Test
+    public void testGetRankForUser() {
+        long experience = 1L;
+        int level = 1;
+        long messageCount = 1L;
+        int rank = 1;
+        AServer server = MockUtils.getServer(2L);
+        AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
+        AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
+        AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
+        when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(experienceObj);
+        LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
+                .builder()
+                .experience(experience)
+                .id(1L)
+                .level(level)
+                .messageCount(messageCount)
+                .rank(rank)
+                .userInServerId(1L)
+                .build();
+        when(userExperienceManagementService.getRankOfUserInServer(experienceObj)).thenReturn(leaderBoardEntryTest);
+        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
+        Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
+        Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(rank, rankOfUserInServer.getRank().intValue());
+    }
+
+    @Test
+    public void testGetRankForUserNotExisting() {
+        AServer server = MockUtils.getServer(2L);
+        AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
+        when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(null);
+        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
+        Assert.assertNull(rankOfUserInServer.getExperience());
+        Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
+    }
+
+    @Test
+    public void testGetRankWhenRankReturnsNull() {
+        long experience = 1L;
+        int level = 1;
+        long messageCount = 1L;
+        AServer server = MockUtils.getServer(2L);
+        AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
+        AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
+        AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).messageCount(messageCount).currentLevel(level0).build();
+        when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(experienceObj);
+        when(userExperienceManagementService.getRankOfUserInServer(experienceObj)).thenReturn(null);
+        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
+        Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
+        Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(messageCount, rankOfUserInServer.getExperience().getMessageCount().longValue());
+        Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
+    }
+
+    @Test
+    public void testSyncRolesWithFeedBack() {
+        AServer server = MockUtils.getServer(1L);
+        AChannel channel = AChannel.builder().id(2L).build();
+        List<AUserExperience> experiences = getUserExperiences(25, server);
+
+        checkStatusMessages(server, channel, experiences, 13);
+    }
+
+    @Test
+    public void testSyncRolesWithNoUsers() {
+        AServer server = MockUtils.getServer(1L);
+        AChannel channel = AChannel.builder().id(2L).build();
+        List<AUserExperience> experiences = new ArrayList<>();
+
+        checkStatusMessages(server, channel, experiences, 1);
+    }
+
+    private void checkStatusMessages(AServer server, AChannel channel, List<AUserExperience> experiences, int messageCount) {
+        when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
+        MessageToSend statusMessage = MessageToSend.builder().message("text").build();
+        when(templateService.renderEmbedTemplate(eq("user_sync_status_message"), any(UserSyncStatusModel.class))).thenReturn(statusMessage);
+        long messageId = 5L;
+        ReceivedMessage statusMessageJDA = MockUtils.buildMockedMessage(messageId, "text", null);
+        when(messageService.createStatusMessage(statusMessage, channel)).thenReturn(CompletableFuture.completedFuture(statusMessageJDA));
+        testUnit.syncUserRolesWithFeedback(server, channel);
+        verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
+    }
+
+    private void executeSyncSingleUserTest(AServer server, List<AExperienceRole> usedExperienceRoles, AExperienceRole previousRole, AExperienceRole afterRole, Integer removals, Integer adds) {
+        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());
+        MemberImpl firstMember = MockUtils.getMockedMember(server, users.get(0), jda);
+        when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(firstMember);
+        experience.setCurrentExperienceRole(previousRole);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
+        when(experienceRoleService.calculateRole(experience, usedExperienceRoles)).thenReturn(afterRole);
+        when(botService.getMemberInServer(server, experience.getUser().getUserReference())).thenReturn(firstMember);
+        if(removals > 0) {
+            users.forEach(aUserInAServer -> when(botService.isUserInGuild(aUserInAServer)).thenReturn(true));
+        }
+        if(afterRole != null && previousRole != null) {
+            boolean sameRole = previousRole.getRole().getId().equals(afterRole.getRole().getId());
+            when(roleService.memberHasRole(firstMember, afterRole.getRole())).thenReturn(sameRole);
+        }
+        testUnit.syncForSingleUser(experience);
+        if(afterRole != null) {
+            Assert.assertEquals(afterRole.getRole().getId(), experience.getCurrentExperienceRole().getRole().getId());
+        } else {
+            Assert.assertNull(experience.getCurrentExperienceRole());
+        }
+        if(previousRole != null) {
+            verify(roleService, times(removals)).removeRoleFromUser(experience.getUser(), previousRole.getRole());
+        }
+        if(afterRole != null) {
+            verify(roleService, times(adds)).addRoleToUser(experience.getUser(), afterRole.getRole());
+        }
+    }
+
+    private void executeLeaderBoardTest(AServer server, Integer page) {
+        int pageSize = 10;
+        List<AUserExperience> experiences = getUserExperiences(pageSize, server);
+        when(userExperienceManagementService.findLeaderboardUsersPaginated(server, (page - 1) * pageSize, page * pageSize)).thenReturn(experiences);
+        LeaderBoard leaderBoardData = testUnit.findLeaderBoardData(server, page);
+        page--;
+        List<LeaderBoardEntry> entries = leaderBoardData.getEntries();
+        for (int i = 0; i < entries.size(); i++) {
+            LeaderBoardEntry entry = entries.get(i);
+            Assert.assertEquals(i, entry.getExperience().getExperience().longValue());
+            Assert.assertEquals(i, entry.getExperience().getCurrentLevel().getLevel().intValue());
+            Assert.assertEquals(i, entry.getExperience().getUser().getUserReference().getId().longValue());
+            Assert.assertEquals((page * pageSize) + i + 1, entry.getRank().intValue());
+        }
+        Assert.assertEquals(pageSize, entries.size());
+    }
+
+    private AExperienceRole testRoleRelatedScenario(boolean shouldHaveRole, List<AExperienceLevel> levels, List<AServer> servers, AServer serverToUse, List<AExperienceRole> experienceRoles, AUserInAServer userToUse, AExperienceRole previousExperienceRole) {
+        mockSimpleServer(levels, experienceRoles, serverToUse);
+        MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
+        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 301L, 1, previousExperienceRole, false);
+
+        AExperienceRole newAwardedRole = experienceRoles.get(3);
+        when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(newAwardedRole);
+        when(roleService.memberHasRole(jdaMember, newAwardedRole.getRole())).thenReturn(shouldHaveRole);
+        testUnit.handleExperienceGain(servers);
+        verify(userExperienceManagementService, times(1)).saveUser(eq(newUserExperience));
+        Assert.assertEquals(3, newUserExperience.getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(3L, newUserExperience.getCurrentExperienceRole().getRole().getId().longValue());
+        return newAwardedRole;
+    }
+
+    private AUserExperience mockServerWithSingleUser(List<AExperienceLevel> levels, AServer serverToUse, Long experience, Integer currentLevelValue, AExperienceRole role, boolean hasExpDisabled) {
+        Optional<AExperienceLevel> first = levels.stream().filter(level -> level.getLevel().equals(currentLevelValue)).findFirst();
+        if(first.isPresent()) {
+            AExperienceLevel currentLevel = first.get();
+            AUserInAServer firstUser = serverToUse.getUsers().get(0);
+            return mockUser(experience, currentLevel, firstUser, hasExpDisabled, role);
+        }
+        throw new AbstractoRunTimeException("No level found");
+    }
+
+    private AUserExperience mockUser(Long experience, AExperienceLevel currentLevel, AUserInAServer firstUser, boolean hasExpDisabled, AExperienceRole currentRole) {
+        AUserExperience newUserExperience = AUserExperience.builder().currentLevel(currentLevel).experience(experience).user(firstUser).experienceGainDisabled(hasExpDisabled).currentExperienceRole(currentRole).build();
+        when(userExperienceManagementService.incrementExpForUser(eq(firstUser), anyLong(), anyLong())).thenReturn(newUserExperience);
+        return newUserExperience;
+    }
+
+    private void mockSimpleServer(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles, AServer server) {
+        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, server.getId())).thenReturn(20L);
+        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, server.getId())).thenReturn(50L);
+        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, server.getId())).thenReturn(1.2);
+        when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
+        when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
+    }
+
+    private List<AServer> getOneServerWithOneUser() {
+        AServer server = MockUtils.getServer(3L);
+        MockUtils.getUserObject(3L, server);
+        return Arrays.asList(server);
+    }
+
+    private List<AServer> getServersWithUserExperience() {
+        AServer server = MockUtils.getServer(3L);
+        AServer otherServer = MockUtils.getServer(3L);
+        MockUtils.getUserObject(3L, server);
+        MockUtils.getUserObject(4L, otherServer);
+
+        return Arrays.asList(server, otherServer);
+    }
+
+}

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

@@ -0,0 +1,61 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExperienceLevelServiceBeanTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    private ExperienceLevelServiceBean testingUnit;
+
+    @Mock
+    private ExperienceLevelManagementService experienceLevelManagementService;
+
+    @Test
+    public void createAFewLevels() {
+        Integer levelCount = 10;
+        Integer existingLevelCount = levelCount - 5;
+        for (int i = 0; i < levelCount; i++) {
+            when(experienceLevelManagementService.levelExists(i)).thenReturn(i < existingLevelCount);
+        }
+        testingUnit.createLevelsUntil(levelCount);
+        verify(experienceLevelManagementService, times(levelCount - existingLevelCount)).createExperienceLevel(anyInt(), anyLong());
+    }
+
+    @Test
+    public void testExperienceToNextLevelCalculation() {
+        when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.of(AExperienceLevel.builder().level(51).experienceNeeded(15L).build()));
+        Long experience = testingUnit.calculateExperienceToNextLevel(50, 10L);
+        Assert.assertEquals(5L, experience.longValue());
+    }
+
+    @Test
+    public void testRequiredExperienceCalculation() {
+        Assert.assertEquals(15100L, testingUnit.calculateExperienceForLevel(50).longValue());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testRequiredExperienceCalculationIllegalLevel() {
+        testingUnit.calculateExperienceForLevel(-1);
+    }
+
+    @Test(expected = AbstractoRunTimeException.class)
+    public void testExperienceToNextLevelCalculationOverExistingLevel() {
+        when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.empty());
+        testingUnit.calculateExperienceToNextLevel(50, 10L);
+    }
+
+}

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

@@ -0,0 +1,162 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.core.models.database.AChannelType;
+import dev.sheldan.abstracto.core.models.database.ARole;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+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 dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
+import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
+import dev.sheldan.abstracto.test.MockUtils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    private ExperienceRoleServiceBean testingUnit;
+
+    @Mock
+    private ExperienceRoleManagementService experienceRoleManagementService;
+
+    @Mock
+    private ExperienceLevelManagementService experienceLevelService;
+
+    @Mock
+    private AUserExperienceService userExperienceService;
+
+
+    @Test
+    public void testSettingRoleToLevelWithoutOldUsers() {
+        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.getRoleInServer(roleToChange)).thenReturn(previousExperienceRole);
+        when(experienceLevelService.getLevel(levelCount)).thenReturn(Optional.of(level));
+        testingUnit.setRoleToLevel(roleToChange, levelCount, getFeedbackChannel(server));
+        verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
+        verify(experienceRoleManagementService, times(1)).removeAllRoleAssignmentsForLevelInServer(level, server);
+        verify(experienceRoleManagementService, times(1)).setLevelToRole(level, roleToChange);
+        verify(experienceRoleManagementService, times(0)).getExperienceRolesForServer(server);
+    }
+
+
+    @Test
+    public void testSettingRoleToLevelExistingUsers() {
+        AServer server = MockUtils.getServer();
+        Integer levelCount = 10;
+        AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
+        ARole roleToChange = getRole(1L, 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 newExperienceRole = AExperienceRole.builder().role(newRoleToAward).id(newRoleToAward.getId()).roleServer(server).level(level).build();
+        when(experienceRoleManagementService.getRoleInServer(roleToChange)).thenReturn(previousExperienceRole);
+        when(experienceLevelService.getLevel(levelCount)).thenReturn(Optional.of(level));
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(new ArrayList<>(Arrays.asList(newExperienceRole, previousExperienceRole)));
+        AChannel feedBackChannel = getFeedbackChannel(server);
+        testingUnit.setRoleToLevel(roleToChange, levelCount, feedBackChannel);
+        verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
+        verify(experienceRoleManagementService, times(1)).removeAllRoleAssignmentsForLevelInServer(level, server);
+        verify(experienceRoleManagementService, times(1)).setLevelToRole(level, roleToChange);
+        verify(experienceRoleManagementService, times(1)).getExperienceRolesForServer(server);
+        verify(userExperienceService, times(1)).executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedBackChannel), any());
+    }
+
+    @Test
+    public void testCalculateRoleForLevelInBetween() {
+        List<AExperienceRole> roles = getExperienceRoles();
+        AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
+        AExperienceRole aExperienceRole = testingUnit.calculateRole(userExperience, roles);
+        Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 5);
+    }
+
+    @Test
+    public void testCalculateRoleForLevelBelow() {
+        List<AExperienceRole> roles = getExperienceRoles();
+        AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(4).build()).build();
+        AExperienceRole aExperienceRole = testingUnit.calculateRole(userExperience, roles);
+        Assert.assertNull(aExperienceRole);
+    }
+
+    @Test
+    public void testCalculateRoleForLevelOver() {
+        List<AExperienceRole> roles = getExperienceRoles();
+        AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(11).build()).build();
+        AExperienceRole aExperienceRole = testingUnit.calculateRole(userExperience, roles);
+        Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 10);
+    }
+
+    @Test
+    public void testCalculateRoleForLevelExact() {
+        List<AExperienceRole> roles = getExperienceRoles();
+        AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(10).build()).build();
+        AExperienceRole aExperienceRole = testingUnit.calculateRole(userExperience, roles);
+        Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 10);
+    }
+
+    @Test
+    public void testCalculateRoleForNoRoleConfigFound() {
+        List<AExperienceRole> roles = new ArrayList<>();
+        AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
+        AExperienceRole aExperienceRole = testingUnit.calculateRole(userExperience, roles);
+        Assert.assertNull(aExperienceRole);
+    }
+
+    @Test
+    public void testCalculatingLevelOfNextRole() {
+        AServer server = MockUtils.getServer();
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(getExperienceRoles());
+        AExperienceLevel levelToCheckFor =  AExperienceLevel.builder().level(7).build();
+        AExperienceLevel levelOfNextRole = testingUnit.getLevelOfNextRole(levelToCheckFor, server);
+        Assert.assertEquals(10, levelOfNextRole.getLevel().intValue());
+    }
+
+    @Test
+    public void testCalculatingLevelOfNextRoleIfThereIsNone() {
+        AServer server = MockUtils.getServer();
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(getExperienceRoles());
+        AExperienceLevel levelToCheckFor =  AExperienceLevel.builder().level(15).build();
+        AExperienceLevel levelOfNextRole = testingUnit.getLevelOfNextRole(levelToCheckFor, server);
+        Assert.assertEquals(200, levelOfNextRole.getLevel().intValue());
+    }
+
+    private List<AExperienceRole> getExperienceRoles() {
+        AExperienceRole level5ExperienceRole = getExperienceRoleForLevel(5);
+        AExperienceRole level10ExperienceRole = getExperienceRoleForLevel(10);
+        return Arrays.asList(level5ExperienceRole, level10ExperienceRole);
+    }
+
+    private AExperienceRole getExperienceRoleForLevel(int levelToBuild) {
+        AExperienceLevel firstLevel = AExperienceLevel.builder().level(levelToBuild).build();
+        return AExperienceRole.builder().level(firstLevel).build();
+    }
+
+    private ARole getRole(Long id, AServer server) {
+        return ARole.builder().id(id).server(server).deleted(false).build();
+    }
+
+    private AChannel getFeedbackChannel(AServer server) {
+        return AChannel.builder().id(1L).server(server).type(AChannelType.TEXT).build();
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class LeaderBoardEntryTestImpl implements LeaderBoardEntryResult {
+
+    private Long id;
+    private Long userInServerId;
+    private Long experience;
+    private Integer level;
+    private Long messageCount;
+    private Integer rank;
+}

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

@@ -0,0 +1,66 @@
+package dev.sheldan.abstracto.experience.service.management;
+
+import dev.sheldan.abstracto.core.models.database.ARole;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
+import dev.sheldan.abstracto.experience.repository.DisabledExpRoleRepository;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DisabledExpRoleManagementServiceBeanTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    private DisabledExpRoleManagementServiceBean testUnit;
+
+    @Mock
+    private DisabledExpRoleRepository disabledExpRoleRepository;
+
+    @Test
+    public void testRoleToSetDisabled() {
+        ARole role = getARole();
+        ADisabledExpRole createdDisabledRole = getDisabledRole(role);
+        when(disabledExpRoleRepository.save(any(ADisabledExpRole.class))).thenReturn(createdDisabledRole);
+        ADisabledExpRole aDisabledExpRole = testUnit.setRoleToBeDisabledForExp(role);
+        Assert.assertEquals(role.getId(), aDisabledExpRole.getRole().getId());
+        Assert.assertEquals(createdDisabledRole.getId(), aDisabledExpRole.getId());
+    }
+
+    @Test
+    public void testIfRoleIsDisabled() {
+        ARole aRole = getARole();
+        when(disabledExpRoleRepository.existsByRole(aRole)).thenReturn(true);
+        boolean experienceDisabledForRole = testUnit.isExperienceDisabledForRole(aRole);
+        Assert.assertTrue(experienceDisabledForRole);
+        verify(disabledExpRoleRepository, times(1)).existsByRole(aRole);
+    }
+
+    @Test
+    public void testRemoveRoleFromDisabled() {
+        ARole aRole = getARole();
+        testUnit.removeRoleToBeDisabledForExp(aRole);
+        verify(disabledExpRoleRepository, times(1)).deleteByRole(aRole);
+    }
+
+    @Test
+    public void testRetrieveAllDisabledRolesForServer() {
+        AServer server = AServer.builder().id(1L).build();
+        testUnit.getDisabledRolesForServer(server);
+        verify(disabledExpRoleRepository, times(1)).getByRole_Server(server);
+    }
+
+    private ADisabledExpRole getDisabledRole(ARole role) {
+        return ADisabledExpRole.builder().role(role).id(2L).build();
+    }
+
+    private ARole getARole() {
+        return ARole.builder().id(1L).build();
+    }
+}

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

@@ -0,0 +1,95 @@
+package dev.sheldan.abstracto.experience.service.management;
+
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.repository.ExperienceLevelRepository;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ExperienceLevelManagementServiceBeanTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    private ExperienceLevelManagementServiceBean testUnit;
+
+    @Mock
+    private ExperienceLevelRepository experienceLevelRepository;
+
+    @Test
+    public void testCreateExperienceLevel() {
+        Integer level = 1;
+        Long neededExperience = 100L;
+        AExperienceLevel createdLevel = getLevel(level, neededExperience);
+        when(experienceLevelRepository.save(any(AExperienceLevel.class))).thenReturn(createdLevel);
+        AExperienceLevel experienceLevel = testUnit.createExperienceLevel(level, neededExperience);
+        Assert.assertEquals(experienceLevel.getLevel(), createdLevel.getLevel());
+        Assert.assertEquals(experienceLevel.getExperienceNeeded(), createdLevel.getExperienceNeeded());
+    }
+
+    @Test
+    public void testLevelExists() {
+        int levelValue = 1;
+        when(experienceLevelRepository.existsById(levelValue)).thenReturn(true);
+        Assert.assertTrue(testUnit.levelExists(levelValue));
+    }
+
+    @Test
+    public void testFindLevel() {
+        int levelValue = 1;
+        long experienceAmount = 100L;
+        Optional<AExperienceLevel> level = Optional.of(getLevel(levelValue, experienceAmount));
+        when(experienceLevelRepository.findById(levelValue)).thenReturn(level);
+        Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevel(levelValue);
+        Assert.assertTrue(foundLevelOptional.isPresent());
+        if(foundLevelOptional.isPresent()) {
+            AExperienceLevel foundLevel = foundLevelOptional.get();
+            Assert.assertEquals(experienceAmount, foundLevel.getExperienceNeeded().longValue());
+            Assert.assertEquals(levelValue, foundLevel.getLevel().intValue());
+        } else {
+            Assert.fail();
+        }
+    }
+
+    @Test
+    public void testFindLevelAndNoLevelFound() {
+        int levelValue = 1;
+        Optional<AExperienceLevel> level = Optional.empty();
+        when(experienceLevelRepository.findById(levelValue)).thenReturn(level);
+        Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevel(levelValue);
+        Assert.assertFalse(foundLevelOptional.isPresent());
+    }
+
+    @Test
+    public void findAllLevelConfigurations() {
+        AExperienceLevel availableLevel = getLevel(1, 100L);
+        AExperienceLevel availableLevel2 = getLevel(2, 200L);
+        List<AExperienceLevel> levelConfig = Arrays.asList(availableLevel, availableLevel2);
+        when(experienceLevelRepository.findAll()).thenReturn(levelConfig);
+        List<AExperienceLevel> foundLevelConfig = testUnit.getLevelConfig();
+        AExperienceLevel firstLevelConfig = foundLevelConfig.get(0);
+        Assert.assertEquals(100L, firstLevelConfig.getExperienceNeeded().longValue());
+        Assert.assertEquals(1, firstLevelConfig.getLevel().intValue());
+        AExperienceLevel secondLevelConfig = foundLevelConfig.get(1);
+        Assert.assertEquals(200L, secondLevelConfig.getExperienceNeeded().longValue());
+        Assert.assertEquals(2, secondLevelConfig.getLevel().intValue());
+    }
+
+    private AExperienceLevel getLevel(Integer level, Long neededExperience) {
+        return AExperienceLevel
+                .builder()
+                .level(level)
+                .experienceNeeded(neededExperience)
+                .build();
+    }
+}

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

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

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

@@ -0,0 +1,175 @@
+package dev.sheldan.abstracto.experience.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
+import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
+import dev.sheldan.abstracto.experience.repository.UserExperienceRepository;
+import dev.sheldan.abstracto.experience.service.LeaderBoardEntryTestImpl;
+import dev.sheldan.abstracto.test.MockUtils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.data.domain.PageRequest;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UserExperienceManagementServiceBeanTest extends ExperienceRelatedTest {
+
+    @InjectMocks
+    private UserExperienceManagementServiceBean testUnit;
+
+    @Mock
+    private UserExperienceRepository repository;
+
+    @Mock
+    private ExperienceLevelManagementService experienceLevelManagementService;
+
+    @Test
+    public void testFindUserInServer() {
+        AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
+        AUserExperience experience = AUserExperience.builder().user(user).experience(2L).build();
+        when(repository.findById(user.getUserInServerId())).thenReturn(Optional.of(experience));
+        AUserExperience userInServer = testUnit.findUserInServer(user);
+        Assert.assertEquals(experience.getExperience(), userInServer.getExperience());
+    }
+
+    @Test
+    public void testNoUserCreateNewWhenSearching() {
+        AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
+        when(repository.findById(user.getUserInServerId())).thenReturn(Optional.empty());
+        AExperienceLevel startLevel = mockInitialLevel();
+        AUserExperience userInServer = testUnit.findUserInServer(user);
+        Assert.assertEquals(0L, userInServer.getExperience().longValue());
+        Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
+        Assert.assertFalse(userInServer.getExperienceGainDisabled());
+        Assert.assertEquals(startLevel.getLevel(), userInServer.getCurrentLevel().getLevel());
+    }
+
+    @Test
+    public void testCreatingUserExperience() {
+        AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
+        AExperienceLevel startLevel = mockInitialLevel();
+        AUserExperience userInServer = testUnit.createUserInServer(user);
+        Assert.assertEquals(0L, userInServer.getExperience().longValue());
+        Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
+        Assert.assertFalse(userInServer.getExperienceGainDisabled());
+        Assert.assertEquals(startLevel.getLevel(), userInServer.getCurrentLevel().getLevel());
+    }
+
+
+    @Test
+    public void testLoadAllUsers() {
+        AServer server = MockUtils.getServer();
+        List<AUserExperience> experiences = getUserExperiences();
+        when(repository.findByUser_ServerReference(server)).thenReturn(experiences);
+        List<AUserExperience> loadedExperiences = testUnit.loadAllUsers(server);
+        Assert.assertEquals(experiences.size(), loadedExperiences.size());
+        Assert.assertEquals(experiences.get(0).getExperience(), loadedExperiences.get(0).getExperience());
+        Assert.assertEquals(experiences.get(1).getExperience(), loadedExperiences.get(1).getExperience());
+    }
+
+    @Test
+    public void testLoadPaginated() {
+        AServer server = MockUtils.getServer();
+        int endIndex = 20;
+        int startIndex = 11;
+        List<AUserExperience> userExperiences = getUserExperiences();
+        when(repository.findTop10ByUser_ServerReferenceOrderByExperienceDesc(server, PageRequest.of(startIndex, endIndex))).thenReturn(userExperiences);
+        List<AUserExperience> leaderboardUsersPaginated = testUnit.findLeaderboardUsersPaginated(server, startIndex, endIndex);
+        Assert.assertEquals(userExperiences.size(), leaderboardUsersPaginated.size());
+        for (int i = 0; i < userExperiences.size(); i++) {
+            Assert.assertEquals(userExperiences.get(i).getExperience(), leaderboardUsersPaginated.get(i).getExperience());
+        }
+    }
+
+    @Test
+    public void testLoadRankOfUser() {
+        long experienceValue = 2L;
+        AUserExperience experience = AUserExperience.builder().experience(experienceValue).id(3L).build();
+        LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
+                .builder()
+                .experience(experienceValue)
+                .build();
+        when(repository.getRankOfUserInServer(experience.getId())).thenReturn(leaderBoardEntryTest);
+        LeaderBoardEntryResult rankOfUserInServer = testUnit.getRankOfUserInServer(experience);
+        Assert.assertEquals(experienceValue, rankOfUserInServer.getExperience().longValue());
+    }
+
+    @Test
+    public void testIncrementExpForUser() {
+        executeTestForExperienceGain(false);
+    }
+
+    @Test
+    public void testIncrementExpForUserWithDisabledExp() {
+        executeTestForExperienceGain(true);
+    }
+
+    @Test
+    public void testIncrementForNonExistingUser() {
+        long addedExperience = 15L;
+        long addedMessages = 1L;
+        AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
+        when(repository.findById(user.getUserInServerId())).thenReturn(Optional.empty());
+        mockInitialLevel();
+        AUserExperience userExperience = testUnit.incrementExpForUser(user, addedExperience, addedMessages);
+        Assert.assertEquals(addedExperience, userExperience.getExperience().longValue());
+        Assert.assertEquals(addedMessages, userExperience.getMessageCount().longValue());
+    }
+
+    @Test
+    public void testSaveUser() {
+        AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
+        AUserExperience experience = AUserExperience.builder().user(user).experience(2L).build();
+        when(repository.save(experience)).thenReturn(experience);
+        AUserExperience createdInstance = testUnit.saveUser(experience);
+        Assert.assertEquals(experience.getExperience(), createdInstance.getExperience());
+        Assert.assertEquals(experience.getUser().getUserReference().getId(), createdInstance.getUser().getUserReference().getId());
+    }
+
+    private AExperienceLevel mockInitialLevel() {
+        AExperienceLevel startLevel = AExperienceLevel.builder().level(0).experienceNeeded(0L).build();
+        when(experienceLevelManagementService.getLevel(startLevel.getLevel())).thenReturn(Optional.of(startLevel));
+        return startLevel;
+    }
+
+    private void executeTestForExperienceGain(boolean experienceGainDisabled) {
+        long oldExperience = 20L;
+        long oldMessageCount = 25L;
+        long addedExperience = 15L;
+        long addedMessages = 1L;
+        AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
+        AUserExperience experience = AUserExperience.builder().user(user).experienceGainDisabled(experienceGainDisabled).experience(oldExperience).messageCount(oldMessageCount).id(3L).build();
+        when(repository.findById(user.getUserInServerId())).thenReturn(Optional.of(experience));
+        AUserExperience userExperience = testUnit.incrementExpForUser(user, addedExperience, addedMessages);
+        long wantedExperience;
+        long wantedMessageCount;
+        if(experienceGainDisabled) {
+            wantedExperience = oldExperience;
+            wantedMessageCount = oldMessageCount;
+        } else {
+            wantedExperience = oldExperience + addedExperience;
+            wantedMessageCount = oldMessageCount + addedMessages;
+        }
+        Assert.assertEquals(wantedExperience, userExperience.getExperience().longValue());
+        Assert.assertEquals(wantedMessageCount, userExperience.getMessageCount().longValue());
+    }
+
+    private List<AUserExperience> getUserExperiences() {
+        AUserExperience experience = AUserExperience.builder().experience(2L).build();
+        AUserExperience experience2 = AUserExperience.builder().experience(2L).build();
+        return Arrays.asList(experience, experience2);
+    }
+}