[AB-149] adding command to reset configuration to default values

removing listener to create system config instances
adding default value retrieval to appropriate places
making config key handling case insensitive
changing exp multiplier to double value
refactoring experience service bean test

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

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
+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;
@@ -16,6 +17,7 @@ import org.springframework.stereotype.Component;
 import java.util.ArrayList;
 import java.util.List;
 
+
 /**
  * Command used to change the experience multiplier on the server.
  */
@@ -23,8 +25,6 @@ import java.util.List;
 @Slf4j
 public class ExpScale extends AbstractConditionableCommand {
 
-    public static final String EXP_MULTIPLIER_KEY = "expMultiplier";
-
     @Autowired
     private ConfigService configService;
 
@@ -32,7 +32,7 @@ public class ExpScale extends AbstractConditionableCommand {
     public CommandResult execute(CommandContext commandContext) {
         Double scale = (Double) commandContext.getParameters().getParameters().get(0);
         Long guildId = commandContext.getGuild().getIdLong();
-        configService.setDoubleValue(EXP_MULTIPLIER_KEY, guildId, scale);
+        configService.setDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, guildId, scale);
         log.info("Setting experience scale to {} for {}", scale, guildId);
         return CommandResult.fromSuccess();
     }

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

@@ -1,33 +0,0 @@
-package dev.sheldan.abstracto.experience.config;
-
-import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
-import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
-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;
-
-/**
- * Listener responsible to configure the required experience configurations in case the bot joins a new server.
- */
-@Component
-@Slf4j
-public class ExperienceConfigListener implements ServerConfigListener {
-
-
-    @Autowired
-    private DefaultConfigManagementService defaultConfigManagementService;
-
-    @Autowired
-    private ConfigManagementService service;
-
-    @Override
-    public void updateServerConfig(AServer server) {
-        log.info("Setting up experience configuration for server {}.", server.getId());
-        service.loadOrCreateIfNotExists(server.getId(), ExperienceFeatureConfig.MIN_EXP_KEY, defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY).getLongValue());
-        service.loadOrCreateIfNotExists(server.getId(), ExperienceFeatureConfig.MAX_EXP_KEY, defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY).getLongValue());
-        service.loadOrCreateIfNotExists(server.getId(), ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY).getDoubleValue());
-    }
-}

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

@@ -4,8 +4,10 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
 import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
@@ -80,6 +82,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Autowired
     private ChannelManagementService channelManagementService;
 
+    @Autowired
+    private DefaultConfigManagementService defaultConfigManagementService;
+
     @Autowired
     private AUserExperienceServiceBean self;
 
@@ -169,13 +174,16 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
         List<ExperienceGainResult> resultFutures = new ArrayList<>();
         List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
         List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
+        SystemConfigProperty defaultExpMultiplier = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY);
+        SystemConfigProperty defaultMinExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY);
+        SystemConfigProperty defaultMaxExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY);
         // TODO what if there are a lot in here...., transaction size etc
         servers.forEach(serverExp -> {
             AServer server = serverManagementService.loadOrCreate(serverExp.getServerId());
             log.info("Handling {} experience for server {}", serverExp.getUserInServerIds().size(), serverExp.getServerId());
-            int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getServerId()).intValue();
+            int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getServerId(), defaultMinExp.getLongValue()).intValue();
-            int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId()).intValue();
+            int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId(), defaultMaxExp.getLongValue()).intValue();
-            Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getServerId());
+            Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getServerId(), defaultExpMultiplier.getDoubleValue());
             PrimitiveIterator.OfInt iterator = new Random().ints(serverExp.getUserInServerIds().size(), minExp, maxExp + 1).iterator();
             levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
             List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/experience-config.properties

@@ -3,7 +3,7 @@ abstracto.systemConfigs.minExp.longValue=10
 abstracto.systemConfigs.maxExp.name=maxExp
 abstracto.systemConfigs.maxExp.longValue=25
 abstracto.systemConfigs.expMultiplier.name=expMultiplier
-abstracto.systemConfigs.expMultiplier.longValue=1
+abstracto.systemConfigs.expMultiplier.doubleValue=1
 
 abstracto.featureFlags.experience.featureName=experience
 abstracto.featureFlags.experience.enabled=false

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

@@ -1,74 +0,0 @@
-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.core.test.MockUtils;
-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 org.mockito.Mock;
-import org.mockito.Mockito;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.mockito.Mockito.when;
-
-
-public abstract class ExperienceRelatedTest {
-
-    @Mock
-    private AServer firstServer;
-
-    @Mock
-    private AServer secondServer;
-
-    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, long i) {
-        AUserInAServer userObject = MockUtils.getUserObject(i, server);
-        AExperienceLevel level = AExperienceLevel
-                .builder()
-                .level((int)i)
-                .experienceNeeded(i * 100)
-                .build();
-        return AUserExperience
-                .builder()
-                .user(userObject)
-                .experience(i)
-                .currentLevel(level)
-                .build();
-    }
-
-    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) {
-        List<AExperienceRole> roles = new ArrayList<>();
-        for (int i = 0; i < levelsWithRoles.size(); i++) {
-            AExperienceLevel level = levelsWithRoles.get(i);
-            ARole role = Mockito.mock(ARole.class);
-            when(role.getId()).thenReturn((long)i);
-            AExperienceRole experienceRole = Mockito.mock(AExperienceRole.class);
-            when(experienceRole.getLevel()).thenReturn(level);
-            when(experienceRole.getId()).thenReturn((long) i);
-            when(experienceRole.getRole()).thenReturn(role);
-            roles.add(experienceRole);
-        }
-        return roles;
-    }
-
-}

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -31,7 +32,7 @@ public class ExpScaleTest {
         CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(newScale));
         CommandResult result = testUnit.execute(context);
         CommandTestUtilities.checkSuccessfulCompletion(result);
-        verify(configService, times(1)).setDoubleValue(ExpScale.EXP_MULTIPLIER_KEY, context.getGuild().getIdLong(), newScale);
+        verify(configService, times(1)).setDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, context.getGuild().getIdLong(), newScale);
     }
 
     @Test

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

@@ -1,11 +1,12 @@
 package dev.sheldan.abstracto.experience.converter;
 
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.test.MockUtils;
-import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
+import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
 import net.dv8tion.jda.api.entities.Member;
@@ -25,7 +26,7 @@ import java.util.concurrent.CompletableFuture;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
-public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
+public class LeaderBoardModelConverterTest {
 
     @InjectMocks
     public LeaderBoardModelConverter testUnit;
@@ -79,4 +80,20 @@ public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
         AUserExperience firstExperience = getUserExperienceObject(server, experienceParameter);
         return LeaderBoardEntry.builder().rank(rank).experience(firstExperience).build();
     }
+
+    private AUserExperience getUserExperienceObject(AServer server, long i) {
+        AUserInAServer userObject = MockUtils.getUserObject(i, server);
+        AExperienceLevel level = AExperienceLevel
+                .builder()
+                .level((int)i)
+                .experienceNeeded(i * 100)
+                .build();
+        return AUserExperience
+                .builder()
+                .user(userObject)
+                .experience(i)
+                .currentLevel(level)
+                .build();
+    }
+
 }

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

@@ -6,7 +6,6 @@ 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 org.junit.Test;
 import org.junit.runner.RunWith;
@@ -18,7 +17,7 @@ import org.mockito.junit.MockitoJUnitRunner;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ExperienceTrackerListenerTest extends ExperienceRelatedTest {
+public class ExperienceTrackerListenerTest {
 
     @InjectMocks
     public ExperienceTrackerListener testUnit;

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

@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.listener;
 import dev.sheldan.abstracto.core.models.ServerUser;
 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.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
@@ -20,7 +19,7 @@ import java.util.concurrent.CompletableFuture;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class JoiningUserRoleListenerTest extends ExperienceRelatedTest {
+public class JoiningUserRoleListenerTest {
 
     @InjectMocks
     private JoiningUserRoleListener testUnit;

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

@@ -1,12 +1,13 @@
 package dev.sheldan.abstracto.experience.service;
 
 import dev.sheldan.abstracto.core.models.database.*;
+import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
 import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.test.MockUtils;
-import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
@@ -15,6 +16,7 @@ import dev.sheldan.abstracto.experience.models.ServerExperience;
 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.database.LeaderBoardEntryResult;
 import dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
@@ -25,6 +27,7 @@ import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.*;
@@ -39,7 +42,7 @@ import java.util.concurrent.CompletableFuture;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
+public class AUserExperienceServiceBeanTest {
 
     @InjectMocks
     private AUserExperienceServiceBean testUnit;
@@ -78,19 +81,16 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
     private MemberService memberService;
 
     @Mock
-    private RunTimeExperienceService runTimeExperienceService;
+    private ServerManagementService serverManagementService;
 
-    @Captor
+    @Mock
-    private ArgumentCaptor<AUserExperience> aUserExperienceArgumentCaptor;
+    private UserInServerManagementService userInServerManagementService;
 
     @Mock
     private AUserExperienceServiceBean self;
 
     @Mock
-    private ServerManagementService serverManagementService;
+    private DefaultConfigManagementService defaultConfigManagementService;
-
-    @Mock
-    private UserInServerManagementService userInServerManagementService;
 
     @Mock
     private AUserExperience userExperience;
@@ -113,9 +113,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
     @Mock
     private ServerExperience serverExperience;
 
-    @Mock
-    private ServerExperience serverExperience2;
-
     @Mock
     private AServer server;
 
@@ -125,48 +122,102 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
     @Mock
     private Member secondMember;
 
+    @Mock
+    private AExperienceLevel level0;
+
+    @Mock
+    private AExperienceLevel level1;
+
+    @Mock
+    private AExperienceLevel level2;
+
+    @Mock
+    private AExperienceLevel level3;
+
+    @Mock
+    private AExperienceRole experienceRole1;
+
+    @Mock
+    private ARole aRole1;
+
+    @Mock
+    private AExperienceRole experienceRole2;
+
+    @Mock
+    private ARole aRole2;
+
+    private List<AExperienceLevel> levels = new ArrayList<>();
+    private List<AExperienceRole> experienceRoles = new ArrayList<>();
+
     private static final Long USER_IN_SERVER_ID = 4L;
     private static final Long USER_ID = 8L;
     private static final Long SERVER_ID = 9L;
     private static final Long CHANNEL_ID = 7L;
+    private static final Long DEFAULT_MIN_EXP = 10L;
+    private static final Long DEFAULT_MAX_EXP = 25L;
+    private static final Double DEFAULT_EXP_MULTIPLIER = 1D;
+    private static final Long LOW_EXP = 50L;
+    private static final Long MID_EXP = 250L;
+    private static final Long HIGH_EXP = 500L;
+    private static final Long LVL_0_EXP = 0L;
+    private static final Long LVL_1_EXP = 100L;
+    private static final Long LVL_2_EXP = 200L;
+    private static final Long LVL_3_EXP = 300L;
+    private static final Integer ZERO_LVL = 0;
+    private static final Integer SECOND_LVL = 2;
+
+    private static final Long ROLE_ID = 4L;
+    private static final Long SECOND_ROLE_ID = 7L;
+
+    @Before
+    public void setup() {
+        this.levels = Arrays.asList(level0, level1, level2, level3);
+        this.experienceRoles = Arrays.asList(experienceRole1, experienceRole2);
+    }
 
     @Test
     public void testCalculateLevelTooLow() {
-        AUserExperience experienceToCalculate = AUserExperience.builder().experience(50L).build();
+        this.levels = Arrays.asList(level0, level1);
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupLevels(1);
-        AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
+        AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, LOW_EXP);
-        Assert.assertEquals(0, calculatedLevel.getLevel().intValue());
+        Assert.assertEquals(level0, calculatedLevel);
     }
 
     @Test
     public void testCalculateLevelBetweenLevels() {
-        AUserExperience experienceToCalculate = AUserExperience.builder().experience(250L).build();
+        this.levels = Arrays.asList(level0, level1, level2);
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupLevels(3);
-        AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
+        AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, MID_EXP);
-        Assert.assertEquals(2, calculatedLevel.getLevel().intValue());
+        Assert.assertEquals(level2, calculatedLevel);
     }
 
     @Test
     public void testCalculateLevelTooHigh() {
-        AUserExperience experienceToCalculate = AUserExperience.builder().experience(500L).build();
+        this.levels = Arrays.asList(level0, level1, level2, level3);
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupLevels(3);
-        AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
+        AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, HIGH_EXP);
-        Assert.assertEquals(3, calculatedLevel.getLevel().intValue());
+        Assert.assertEquals(level3, calculatedLevel);
     }
 
     @Test
     public void testUpdateUserExperienceLevelChanged() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        AUserExperience experienceToCalculate = Mockito.mock(AUserExperience.class);
-        AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
+        when(experienceToCalculate.getUser()).thenReturn(aUserInAServer);
-        AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(1)).experience(250L).build();
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        Assert.assertTrue(testUnit.updateUserLevel(experienceToCalculate, levels, experienceToCalculate.getExperience()));
+        when(experienceToCalculate.getCurrentLevel()).thenReturn(level0);
+        when(level0.getLevel()).thenReturn(ZERO_LVL);
+        when(level2.getLevel()).thenReturn(SECOND_LVL);
+        setupLevels(3);
+        Assert.assertTrue(testUnit.updateUserLevel(experienceToCalculate, levels, MID_EXP));
+        verify(experienceToCalculate, times(1)).setCurrentLevel(level2);
     }
 
     @Test
     public void testUpdateUserExperienceLevelNotChanged() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        AUserExperience experienceToCalculate = Mockito.mock(AUserExperience.class);
-        AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
+        when(experienceToCalculate.getCurrentLevel()).thenReturn(level2);
-        AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(2)).experience(250L).build();
+        when(experienceToCalculate.getExperience()).thenReturn(MID_EXP);
+        setupLevels(3);
         Assert.assertFalse(testUnit.updateUserLevel(experienceToCalculate, levels, experienceToCalculate.getExperience()));
     }
 
@@ -176,125 +227,145 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
          * In this scenario, the user has a role before, but the config changed, and now there are no experience roles.
          * Hence the user should lose the experience role.
          */
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        setupServerId();
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupLevels(3);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
-        AExperienceRole previousExperienceRole = experienceRoles.get(1);
+        setExperienceRoleLevels();
-        setupSimpleSingleUserTest(levels, experienceRoles);
+        AExperienceRole previousExperienceRole = experienceRole1;
-        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
+        setupServerConfig();
-        when(roleService.removeRoleFromUserFuture(userExperience.getUser(), userExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
+        setupDefaultConfig();
+        setupLevelsAndRolesAndNoDisallowed();
+        setupUserInServer();
+        when(userExperience.getExperience()).thenReturn(500L);
         when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        testUnit.handleExperienceGain(servers).join();
+        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
-        verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, previousExperienceRole.getRole());
+        when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
-        verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
+        verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, aRole1);
+        verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any());
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testLevelUpGainingNewRoleButUserAlreadyHasRole() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        setupServerConfig();
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setupDefaultConfig();
-        AExperienceRole previousExperienceRole = experienceRoles.get(1);
+        setupLevelsAndRolesAndNoDisallowed();
-        setupSimpleSingleUserTest(levels, experienceRoles);
+        when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
+        setupUserInServer();
         when(userExperience.getExperience()).thenReturn(199L);
-        AExperienceRole newRole = experienceRoles.get(2);
+        when(experienceRole1.getLevel()).thenReturn(level0);
+        when(experienceRole2.getRole()).thenReturn(aRole2);
+        when(experienceRole2.getLevel()).thenReturn(level1);
+        AExperienceRole newRole = experienceRole2;
+        when(aRole2.getId()).thenReturn(ROLE_ID);
         when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
-        AExperienceRole newAwardedRole = experienceRoles.get(3);
+        when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
-        when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(true);
         when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        testUnit.handleExperienceGain(servers).join();
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
-        verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
+        verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
-        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
+        verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testLevelUpNotGainingNewRole() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setExperienceRoleLevels();
-        AExperienceRole previousExperienceRole = experienceRoles.get(1);
+        when(aRole1.getId()).thenReturn(ROLE_ID);
-        setupSimpleSingleUserTest(levels, experienceRoles);
+        setupServerConfig();
-        AExperienceRole newRole = experienceRoles.get(1);
+        setupDefaultConfig();
+        setupLevelsAndRolesAndNoDisallowed();
+        when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
+        setupUserInServer();
+        when(userExperience.getExperience()).thenReturn(500L);
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        AExperienceRole newRole = experienceRole1;
         when(userExperience.getCurrentExperienceRole()).thenReturn(newRole);
         when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
 
-        when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(true);
+        when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
-        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
-        testUnit.handleExperienceGain(servers).join();
+        verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
-        verify(roleService, times(0)).addRoleToUser(aUserInAServer, newRole.getRole());
+        verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
-        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testHandleExperienceForUserNotLevelingUpWithoutExistingRole() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        when(userExperience.getCurrentExperienceRole()).thenReturn(null);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setupServerConfig();
-        AExperienceRole previousExperienceRole = null;
+        setupDefaultConfig();
-        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
+        setupLevelsAndRolesAndNoDisallowed();
-        setupSimpleSingleUserTest(levels, experienceRoles);
+        when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
-        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
+        setupUserInServer();
-        AExperienceRole newRole = experienceRoles.get(1);
+        when(userExperience.getExperience()).thenReturn(500L);
+        AExperienceRole newRole = experienceRole1;
         when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
-
+        when(aRole1.getId()).thenReturn(ROLE_ID);
-        when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(false);
+        setupTwoExperienceRoles();
-        when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(false);
+        when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
         when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
-        testUnit.handleExperienceGain(servers).join();
+        CompletableFuture<Void> future = testUnit.handleExperienceGain(Arrays.asList(serverExperience));
+        future.join();
+        Assert.assertFalse(future.isCompletedExceptionally());
+        verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any(ARole.class));
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void handleExpGainWithTooLittleForRole() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        setupServerConfig();
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setupDefaultConfig();
-        AExperienceRole previousExperienceRole = null;
+        setupLevelsAndRolesAndNoDisallowed();
-        setupSimpleSingleUserTest(levels, experienceRoles);
+        setupUserInServer();
         when(userExperience.getExperience()).thenReturn(50L);
+        setExperienceRoleLevels();
         when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
+        when(userExperience.getCurrentExperienceRole()).thenReturn(null);
-        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
-        AExperienceRole newRole = null;
-        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
 
-        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
-        testUnit.handleExperienceGain(servers).join();
         verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
         verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testUserHasExperienceRoleButNotAnymore() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        setupServerConfig();
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setupDefaultConfig();
-        setupSimpleSingleUserTest(levels, experienceRoles);
+        setupLevelsAndRolesAndNoDisallowed();
+        setupUserInServer();
         when(userExperience.getExperience()).thenReturn(50L);
-        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
+        AExperienceRole previousExperienceRole = experienceRole1;
-        AExperienceRole previousExperienceRole = experienceRoles.get(0);
         when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
-        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
-        AExperienceRole newRole = null;
+        setExperienceRoleLevels();
-        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
 
         when(roleService.removeRoleFromUserFuture(eq(aUserInAServer), any())).thenReturn(CompletableFuture.completedFuture(null));
         when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        testUnit.handleExperienceGain(servers).join();
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
         verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
         verify(roleService, times(1)).removeRoleFromUserFuture(eq(aUserInAServer), any());
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testHandleExperienceGainForGainDisabledForUser() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
         setupServerConfig();
-        when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
+        setupDefaultConfig();
-        when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
+        setupLevelsAndRolesAndNoDisallowed();
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setExperienceRoleLevels();
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
         when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
@@ -302,84 +373,86 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         when(userExperience.getExperienceGainDisabled()).thenReturn(true);
 
         when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        testUnit.handleExperienceGain(servers).join();
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
         verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
         verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testHandleExperienceGainForGainDisabledForRole() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
-        ServerExperience serverToUse = servers.get(0);
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
+        setupServerConfig();
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        setupDefaultConfig();
-        testUnit.handleExperienceGain(servers).join();
+        setupLevelsAndRolesAndNoDisallowed();
-        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
+        setExperienceRoleLevels();
+        testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
+        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
         verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testHandleExperienceForUserNotLevelingUpWithExistingRole() {
-        List<AExperienceLevel> levels = getLevelConfiguration();
+        setupServerId();
-        List<ServerExperience> servers = Arrays.asList(serverExperience);
+        when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
         when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        ServerExperience serverToUse = servers.get(0);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        mockSimpleServer(levels, experienceRoles, serverExperience);
-        Long userToUse = serverToUse.getUserInServerIds().get(0);
-        when(userExperienceManagementService.findByUserInServerIdOptional(userToUse)).thenReturn(Optional.of(userExperience));
         when(userExperience.getUser()).thenReturn(aUserInAServer);
-        when(userInServerManagementService.loadOrCreateUser(userToUse)).thenReturn(aUserInAServer);
+        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(aUserInAServer.getServerReference()).thenReturn(server);
-        when(server.getId()).thenReturn(8L);
-        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
         when(roleService.hasAnyOfTheRoles(eq(firstMember), anyList())).thenReturn(false);
-        when(user.getId()).thenReturn(7L);
+        when(user.getId()).thenReturn(USER_ID);
-        CompletableFuture<Void> future = testUnit.handleExperienceGain(servers);
+        setExperienceRoleLevels();
+
+        setupServerConfig();
+        setupDefaultConfig();
+        setupLevelsAndRolesAndNoDisallowed();
+
+        CompletableFuture<Void> future = testUnit.handleExperienceGain(Arrays.asList(serverExperience));
         future.join();
-        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
+        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
         verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
+        verify(self, times(1)).persistExperienceChanges(anyList());
     }
 
     @Test
     public void testSyncNoRoleUserGettingRole2() {
-        AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
-        AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
         userExperience.setCurrentExperienceRole(null);
-        AExperienceRole afterRole = usedExperienceRoles.get(0);
+        AExperienceRole afterRole = experienceRole1;
+        when(experienceRole1.getRole()).thenReturn(aRole1);
+        when(experienceRole1.getId()).thenReturn(ROLE_ID);
+        when(aRole1.getId()).thenReturn(ROLE_ID);
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(aUserInAServer.getServerReference()).thenReturn(server);
         when(userExperience.getUser()).thenReturn(aUserInAServer);
 
         when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
 
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
+        when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
         when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
-        when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
         RoleCalculationResult result = calculationFuture.join();
-        Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
+        Assert.assertEquals(ROLE_ID, result.getExperienceRoleId());
     }
 
     @Test
     public void testSyncUserLosingRole() {
-        AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
+        AExperienceRole beforeRole = experienceRole1;
-        AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
-        AExperienceRole beforeRole = usedExperienceRoles.get(0);
         when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
-        AExperienceRole afterRole = null;
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(aUserInAServer.getServerReference()).thenReturn(server);
         when(userExperience.getUser()).thenReturn(aUserInAServer);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
 
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
+        when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(null);
-        when(roleService.removeRoleFromUserFuture(aUserInAServer, beforeRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
         RoleCalculationResult result = calculationFuture.join();
         Assert.assertNull(result.getExperienceRoleId());
@@ -387,87 +460,74 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testSyncUserKeepingRole() {
-        AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
+        AExperienceRole beforeRole = experienceRole1;
-        AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
-        AExperienceRole beforeRole = usedExperienceRoles.get(0);
         when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
-        AExperienceRole afterRole = usedExperienceRoles.get(0);
+        AExperienceRole afterRole = experienceRole1;
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(aUserInAServer.getServerReference()).thenReturn(server);
         when(userExperience.getUser()).thenReturn(aUserInAServer);
-
+        when(aRole1.getId()).thenReturn(ROLE_ID);
+        when(experienceRole1.getId()).thenReturn(ROLE_ID);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
         when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
 
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
+        when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
         when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
-        when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(true);
+        when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
         CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
         RoleCalculationResult result = calculationFuture.join();
-        Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
+        Assert.assertEquals(ROLE_ID, result.getExperienceRoleId());
     }
 
     @Test
     public void testSyncUserChangingRole() {
-        AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
+        AExperienceRole beforeRole = experienceRole1;
-        AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
-        AExperienceRole beforeRole = usedExperienceRoles.get(0);
         when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
-        AExperienceRole afterRole = usedExperienceRoles.get(1);
+        AExperienceRole afterRole = experienceRole2;
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(aUserInAServer.getServerReference()).thenReturn(server);
         when(userExperience.getUser()).thenReturn(aUserInAServer);
-        when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
+
+        when(aRole1.getId()).thenReturn(ROLE_ID);
+        when(aRole2.getId()).thenReturn(SECOND_ROLE_ID);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
+        when(experienceRole2.getRole()).thenReturn(aRole2);
+        when(experienceRole2.getId()).thenReturn(SECOND_ROLE_ID);
+
+        when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
 
         when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
 
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
+        when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
-        when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
+        when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
-        when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
+        when(roleService.memberHasRole(firstMember, SECOND_ROLE_ID)).thenReturn(false);
-        when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.removeRoleFromMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
-        when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.addRoleToMemberFuture(firstMember, SECOND_ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
         RoleCalculationResult result = calculationFuture.join();
-        Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
+        Assert.assertEquals(SECOND_ROLE_ID, result.getExperienceRoleId());
     }
 
     @Test
     public void testDisablingExperienceForUser() {
-        AUserInAServer userObject = MockUtils.getUserObject(2L, server);
+        AUserExperience experience = Mockito.mock(AUserExperience.class);
-        AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
+        when(aUserInAServer.getServerReference()).thenReturn(server);
-        testUnit.disableExperienceForUser(userObject);
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
-        Assert.assertTrue(experience.getExperienceGainDisabled());
+        testUnit.disableExperienceForUser(aUserInAServer);
+        verify(experience, times(1)).setExperienceGainDisabled(true);
     }
 
     @Test
-    public void testDisablingExpForUserWhichHasItDisabled() {
+    public void testEnablingExpForUser() {
-        AUserInAServer userObject = MockUtils.getUserObject(2L, server);
+        AUserExperience experience = Mockito.mock(AUserExperience.class);
-        AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
+        when(aUserInAServer.getServerReference()).thenReturn(server);
-        testUnit.disableExperienceForUser(userObject);
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
-        Assert.assertTrue(experience.getExperienceGainDisabled());
+        testUnit.enableExperienceForUser(aUserInAServer);
-    }
+        verify(experience, times(1)).setExperienceGainDisabled(false);
-
-    @Test
-    public void testEnablingExperienceForEnabledUser() {
-        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() {
-        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
@@ -482,18 +542,15 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void testIllegalLeaderBoardPage() {
-        testUnit.findLeaderBoardData(MockUtils.getServer(1L), -1);
+        testUnit.findLeaderBoardData(server, -1);
     }
 
     @Test
     public void testSyncAllUsers() {
-        AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
+        AExperienceRole beforeRole = experienceRole1;
-        AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
-        AExperienceRole beforeRole = usedExperienceRoles.get(0);
 
         when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
-        AExperienceRole afterRole = usedExperienceRoles.get(1);
+        AExperienceRole afterRole = experienceRole2;
         when(aUserInAServer.getUserReference()).thenReturn(user);
         when(user.getId()).thenReturn(8L);
         when(aUserInAServer.getServerReference()).thenReturn(server);
@@ -511,78 +568,65 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
         when(memberService.getMemberInServerAsync(aUserInAServer2)).thenReturn(CompletableFuture.completedFuture(secondMember));
 
-        when(server.getId()).thenReturn(15L);
 
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
+        when(aRole1.getId()).thenReturn(ROLE_ID);
-        when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
+        when(aRole2.getId()).thenReturn(SECOND_ROLE_ID);
-        when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
+        when(experienceRole1.getRole()).thenReturn(aRole1);
-        when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
+        when(experienceRole2.getRole()).thenReturn(aRole2);
-        when(memberService.getMemberInServerAsync(userExperience2.getUser())).thenReturn(CompletableFuture.completedFuture(secondMember));
+        when(experienceRole2.getId()).thenReturn(SECOND_ROLE_ID);
-        when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
+
-        when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(roleService.memberHasRole(secondMember, afterRole.getRole().getId())).thenReturn(true);
+        when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
-        when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(experienceRoleService.calculateRole(experienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
-        when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
+        when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
+        when(memberService.getMemberInServerAsync(aUserInAServer2)).thenReturn(CompletableFuture.completedFuture(secondMember));
+        when(roleService.memberHasRole(firstMember, SECOND_ROLE_ID)).thenReturn(false);
+        when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
+        when(roleService.memberHasRole(secondMember, SECOND_ROLE_ID)).thenReturn(true);
+        when(roleService.removeRoleFromMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
+        when(roleService.addRoleToMemberFuture(firstMember,SECOND_ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
         List<AUserExperience> experiences = Arrays.asList(userExperience, userExperience2);
         when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
         List<CompletableFuture<RoleCalculationResult>> calculationFutures = testUnit.syncUserRoles(server);
-        verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, beforeRole.getRole().getId());
+        verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, ROLE_ID);
-        verify(roleService, times(0)).addRoleToMemberFuture(secondMember, afterRole.getRole().getId());
+        verify(roleService, times(0)).addRoleToMemberFuture(secondMember, SECOND_ROLE_ID);
         RoleCalculationResult firstResult = calculationFutures.get(0).join();
-        Assert.assertEquals(afterRole.getRole().getId(), firstResult.getExperienceRoleId());
+        Assert.assertEquals(SECOND_ROLE_ID, firstResult.getExperienceRoleId());
         RoleCalculationResult secondResult = calculationFutures.get(1).join();
-        Assert.assertEquals(afterRole.getRole().getId(), secondResult.getExperienceRoleId());
+        Assert.assertEquals(SECOND_ROLE_ID, secondResult.getExperienceRoleId());
     }
 
     @Test
     public void testGetRankForUser() {
-        long experience = 1L;
-        int level = 1;
-        long messageCount = 1L;
         int rank = 1;
-        AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
+        AUserExperience experienceObj = Mockito.mock(AUserExperience.class);
-        AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experienceObj);
-        when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(experienceObj);
+        LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
-        LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
+        when(leaderBoardEntryTest.getRank()).thenReturn(rank);
-                .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);
+        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
-        Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
+        Assert.assertEquals(experienceObj, rankOfUserInServer.getExperience());
-        Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
         Assert.assertEquals(rank, rankOfUserInServer.getRank().intValue());
     }
 
     @Test
     public void testGetRankForUserNotExisting() {
-        AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(null);
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(null);
-        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
+        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
         Assert.assertNull(rankOfUserInServer.getExperience());
         Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
     }
 
     @Test
     public void testGetRankWhenRankReturnsNull() {
-        long experience = 1L;
+        AUserExperience experienceObj = Mockito.mock(AUserExperience.class);
-        int level = 1;
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        long messageCount = 1L;
+        when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experienceObj);
-        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);
+        LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
-        Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
+        Assert.assertEquals(experienceObj, rankOfUserInServer.getExperience());
-        Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
-        Assert.assertEquals(messageCount, rankOfUserInServer.getExperience().getMessageCount().longValue());
         Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
     }
 
@@ -591,7 +635,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         AChannel channel = Mockito.mock(AChannel.class);
         when(channel.getServer()).thenReturn(server);
         when(server.getId()).thenReturn(SERVER_ID);
-        List<AUserExperience> experiences = getUserExperiences(25, server);
+        List<AUserExperience> experiences = getUserExperiences(25);
 
         checkStatusMessages(server, channel, experiences, 13);
     }
@@ -605,35 +649,9 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         checkStatusMessages(server, channel, experiences, 1);
     }
 
-    private void setupServerConfig() {
-        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExperience.getServerId())).thenReturn(20L);
-        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExperience.getServerId())).thenReturn(50L);
-        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExperience.getServerId())).thenReturn(1.2);
-    }
-
-    private void setupSimpleSingleUserTest(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles) {
-        setupServerConfig();
-        when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
-        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
-        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
-        when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
-        when(user.getId()).thenReturn(USER_ID);
-        when(aUserInAServer.getUserReference()).thenReturn(user);
-        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
-        when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
-        when(userExperience.getExperience()).thenReturn(500L);
-        when(userExperience.getUser()).thenReturn(aUserInAServer);
-        when(aUserInAServer.getUserReference()).thenReturn(user);
-        when(aUserInAServer.getServerReference()).thenReturn(server);
-        when(server.getId()).thenReturn(SERVER_ID);
-        when(user.getId()).thenReturn(USER_ID);
-    }
-
     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();
+        MessageToSend statusMessage = Mockito.mock(MessageToSend.class);
         when(templateService.renderEmbedTemplate(eq("user_sync_status_message"), any(UserSyncStatusModel.class), eq(SERVER_ID))).thenReturn(statusMessage);
         long messageId = 5L;
         Message statusMessageJDA = Mockito.mock(Message.class);
@@ -644,32 +662,109 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
     }
 
+    private void setupUserInServer() {
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
+        when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
+        when(aUserInAServer.getUserReference()).thenReturn(user);
+        when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
+        when(userExperience.getUser()).thenReturn(aUserInAServer);
+        when(aUserInAServer.getServerReference()).thenReturn(server);
+        when(user.getId()).thenReturn(USER_ID);
+    }
+
+    private void setupTwoExperienceRoles() {
+        when(experienceRole1.getRole()).thenReturn(aRole1);
+        setExperienceRoleLevels();
+    }
+
+    private void setupServerId() {
+        when(server.getId()).thenReturn(SERVER_ID);
+        when(serverExperience.getServerId()).thenReturn(SERVER_ID);
+        when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
+    }
+
+    private void setupServerConfig() {
+        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, SERVER_ID, DEFAULT_MIN_EXP)).thenReturn(20L);
+        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, SERVER_ID, DEFAULT_MAX_EXP)).thenReturn(50L);
+        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, SERVER_ID, DEFAULT_EXP_MULTIPLIER)).thenReturn(1.2);
+    }
+
     private void executeLeaderBoardTest(AServer server, Integer page) {
         int pageSize = 10;
-        List<AUserExperience> experiences = getUserExperiences(pageSize, server);
+        List<AUserExperience> experiences = Arrays.asList(userExperience, userExperience2);
+        when(userExperience.getExperience()).thenReturn(LOW_EXP);
+        when(userExperience.getCurrentLevel()).thenReturn(level0);
+        when(userExperience.getUser()).thenReturn(aUserInAServer);
+        when(userExperience2.getExperience()).thenReturn(MID_EXP);
+        when(userExperience2.getCurrentLevel()).thenReturn(level1);
+        when(userExperience2.getUser()).thenReturn(aUserInAServer2);
         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 firstEntry = entries.get(0);
-            LeaderBoardEntry entry = entries.get(i);
+        Assert.assertEquals(LOW_EXP, firstEntry.getExperience().getExperience());
-            Assert.assertEquals(i, entry.getExperience().getExperience().longValue());
+        Assert.assertEquals(level0, firstEntry.getExperience().getCurrentLevel());
-            Assert.assertEquals(i, entry.getExperience().getCurrentLevel().getLevel().intValue());
+        Assert.assertEquals(aUserInAServer, firstEntry.getExperience().getUser());
-            Assert.assertEquals(i, entry.getExperience().getUser().getUserReference().getId().longValue());
+        Assert.assertEquals((page * pageSize) + 1, firstEntry.getRank().intValue());
-            Assert.assertEquals((page * pageSize) + i + 1, entry.getRank().intValue());
+        LeaderBoardEntry secondEntry = entries.get(1);
-        }
+        Assert.assertEquals(MID_EXP, secondEntry.getExperience().getExperience());
-        Assert.assertEquals(pageSize, entries.size());
+        Assert.assertEquals(level1, secondEntry.getExperience().getCurrentLevel());
+        Assert.assertEquals(aUserInAServer2, secondEntry.getExperience().getUser());
+        Assert.assertEquals((page * pageSize) + 2, secondEntry.getRank().intValue());
+        Assert.assertEquals(2, entries.size());
     }
 
-    private void mockSimpleServer(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles, ServerExperience serverExperience) {
+    private void setExperienceRoleLevels() {
-        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExperience.getServerId())).thenReturn(20L);
+        when(experienceRole1.getLevel()).thenReturn(level0);
-        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExperience.getServerId())).thenReturn(50L);
+        when(experienceRole2.getLevel()).thenReturn(level1);
-        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExperience.getServerId())).thenReturn(1.2);
+    }
-        when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
+
+    private void setupLevelsAndRolesAndNoDisallowed() {
         when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
         when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
         when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
     }
 
+    private void setupDefaultConfig() {
+        SystemConfigProperty minExpProperty = Mockito.mock(SystemConfigProperty.class);
+        when(minExpProperty.getLongValue()).thenReturn(DEFAULT_MIN_EXP);
+        when(defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY)).thenReturn(minExpProperty);
+        SystemConfigProperty maxExpProperty = Mockito.mock(SystemConfigProperty.class);
+        when(maxExpProperty.getLongValue()).thenReturn(DEFAULT_MAX_EXP);
+        when(defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY)).thenReturn(maxExpProperty);
+        SystemConfigProperty expMultiplierProperty = Mockito.mock(SystemConfigProperty.class);
+        when(expMultiplierProperty.getDoubleValue()).thenReturn(DEFAULT_EXP_MULTIPLIER);
+        when(defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY)).thenReturn(expMultiplierProperty);
+    }
+
+    protected List<AUserExperience> getUserExperiences(int count) {
+        List<AUserExperience> experiences = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            AUserExperience experience = Mockito.mock(AUserExperience.class);
+            when(experience.getUser()).thenReturn(aUserInAServer);
+            when(aUserInAServer.getServerReference()).thenReturn(server);
+            when(aUserInAServer.getUserReference()).thenReturn(user);
+            experiences.add(experience);
+        }
+        return experiences;
+    }
+
+    private void setupLevels(int count) {
+        if(count >= 0) {
+            when(level0.getExperienceNeeded()).thenReturn(LVL_0_EXP);
+        }
+        if(count >= 1) {
+            when(level1.getExperienceNeeded()).thenReturn(LVL_1_EXP);
+        }
+        if(count >= 2) {
+            when(level2.getExperienceNeeded()).thenReturn(LVL_2_EXP);
+        }
+        if(count >= 3) {
+            when(level3.getExperienceNeeded()).thenReturn(LVL_3_EXP);
+        }
+    }
+
 
 }

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

@@ -1,7 +1,6 @@
 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;
@@ -16,7 +15,7 @@ import java.util.Optional;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ExperienceLevelServiceBeanTest extends ExperienceRelatedTest {
+public class ExperienceLevelServiceBeanTest {
 
     @InjectMocks
     private ExperienceLevelServiceBean testingUnit;

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

@@ -7,7 +7,6 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
-import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
 import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
@@ -32,7 +31,7 @@ import java.util.concurrent.CompletableFuture;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
+public class ExperienceRoleServiceBeanTest {
 
     @InjectMocks
     private ExperienceRoleServiceBean testingUnit;
@@ -127,7 +126,7 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         List<AExperienceRole> roles = getExperienceRoles();
         AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
         AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
-        Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 5);
+        Assert.assertEquals(5, aExperienceRole.getLevel().getLevel().intValue());
     }
 
     @Test
@@ -143,7 +142,7 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         List<AExperienceRole> roles = getExperienceRoles();
         AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(11).build()).build();
         AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
-        Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 10);
+        Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
     }
 
     @Test
@@ -151,7 +150,7 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         List<AExperienceRole> roles = getExperienceRoles();
         AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(10).build()).build();
         AExperienceRole aExperienceRole = testingUnit.calculateRole(roles,  userExperience.getLevelOrDefault());
-        Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 10);
+        Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
     }
 
     @Test

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

@@ -1,17 +0,0 @@
-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

@@ -2,7 +2,6 @@ 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;
@@ -15,7 +14,7 @@ import org.mockito.junit.MockitoJUnitRunner;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class DisabledExpRoleManagementServiceBeanTest extends ExperienceRelatedTest {
+public class DisabledExpRoleManagementServiceBeanTest {
 
     @InjectMocks
     private DisabledExpRoleManagementServiceBean testUnit;

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

@@ -1,6 +1,5 @@
 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;
@@ -18,7 +17,7 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ExperienceLevelManagementServiceBeanTest extends ExperienceRelatedTest {
+public class ExperienceLevelManagementServiceBeanTest {
 
     @InjectMocks
     private ExperienceLevelManagementServiceBean testUnit;

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

@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.service.management;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.test.MockUtils;
-import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.repository.ExperienceRoleRepository;
@@ -25,7 +24,7 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ExperienceRoleManagementServiceBeanTest extends ExperienceRelatedTest {
+public class ExperienceRoleManagementServiceBeanTest {
 
     @InjectMocks
     private ExperienceRoleManagementServiceBean testUnit;

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

@@ -4,12 +4,10 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.test.MockUtils;
-import dev.sheldan.abstracto.experience.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 org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -26,7 +24,7 @@ import java.util.Optional;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
-public class UserExperienceManagementServiceBeanTest extends ExperienceRelatedTest {
+public class UserExperienceManagementServiceBeanTest {
 
     @InjectMocks
     private UserExperienceManagementServiceBean testUnit;
@@ -113,10 +111,8 @@ public class UserExperienceManagementServiceBeanTest extends ExperienceRelatedTe
         AServer server = MockUtils.getServer();
         AUserInAServer user = MockUtils.getUserObject(6L, server);
         AUserExperience experience = AUserExperience.builder().experience(experienceValue).user(user).id(3L).build();
-        LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
+        LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
-                .builder()
+        when(leaderBoardEntryTest.getExperience()).thenReturn(experienceValue);
-                .experience(experienceValue)
-                .build();
         when(repository.getRankOfUserInServer(experience.getId(), server.getId())).thenReturn(leaderBoardEntryTest);
         LeaderBoardEntryResult rankOfUserInServer = testUnit.getRankOfUserInServer(experience);
         Assert.assertEquals(experienceValue, rankOfUserInServer.getExperience().longValue());

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/WarnDecayConfigListener.java

@@ -1,27 +0,0 @@
-package dev.sheldan.abstracto.moderation.listener;
-
-import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
-import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
-import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-@Slf4j
-public class WarnDecayConfigListener implements ServerConfigListener {
-
-    @Autowired
-    private ConfigManagementService configManagementService;
-
-    @Autowired
-    private DefaultConfigManagementService defaultConfigManagementService;
-
-    @Override
-    public void updateServerConfig(AServer server) {
-        log.info("Updating decay day configuration for server {}.", server.getId());
-        configManagementService.loadOrCreateIfNotExists(server.getId(), WarningDecayFeature.DECAY_DAYS_KEY, defaultConfigManagementService.getDefaultConfig(WarningDecayFeature.DECAY_DAYS_KEY).getLongValue());
-    }
-}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/WarnServiceBean.java

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.models.ServerSpecificId;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.*;
+import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
@@ -70,6 +71,9 @@ public class WarnServiceBean implements WarnService {
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private DefaultConfigManagementService defaultConfigManagementService;
+
     @Autowired
     private FeatureModeService featureModeService;
 
@@ -124,8 +128,9 @@ public class WarnServiceBean implements WarnService {
 
     @Override
     @Transactional
-    public CompletableFuture<Void>  decayWarningsForServer(AServer server) {
+    public CompletableFuture<Void> decayWarningsForServer(AServer server) {
-        Long days = configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId());
+        Long defaultDays = defaultConfigManagementService.getDefaultConfig(WarningDecayFeature.DECAY_DAYS_KEY).getLongValue();
+        Long days = configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId(), defaultDays);
         Instant cutOffDay = Instant.now().minus(days, ChronoUnit.DAYS);
         log.info("Decaying warnings on server {} which are older than {}.", server.getId(), cutOffDay);
         List<Warning> warningsToDecay = warnManagementService.getActiveWarningsInServerOlderThan(server, cutOffDay);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/WarnServiceBeanTest.java

@@ -3,7 +3,9 @@ package dev.sheldan.abstracto.moderation.service;
 import dev.sheldan.abstracto.core.models.ServerSpecificId;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
 import dev.sheldan.abstracto.core.service.*;
+import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
@@ -24,10 +26,7 @@ import net.dv8tion.jda.api.entities.User;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
+import org.mockito.*;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.time.Instant;
@@ -122,6 +121,9 @@ public class WarnServiceBeanTest {
     @Mock
     private FeatureModeService featureModeService;
 
+    @Mock
+    private DefaultConfigManagementService defaultConfigManagementService;
+
     private static final String NOTIFICATION_TEXT = "text";
     private static final String GUILD_NAME = "guild";
     private static final Long SERVER_ID = 4L;
@@ -129,7 +131,7 @@ public class WarnServiceBeanTest {
     @Test
     public void testDecayWarning() {
         Instant date = Instant.now();
-        when(firstWarning.getWarnId()).thenReturn(new ServerSpecificId(3L, 4L));
+        when(firstWarning.getWarnId()).thenReturn(new ServerSpecificId(SERVER_ID, 4L));
         testUnit.decayWarning(firstWarning, date);
         verify(firstWarning, times(1)).setDecayed(true);
         verify(firstWarning, times(1)).setDecayDate(date);
@@ -233,7 +235,11 @@ public class WarnServiceBeanTest {
 
     private void setupWarnDecay() {
         setupWarnings();
-        when(configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId())).thenReturn(5L);
+        SystemConfigProperty defaultDecayDays = Mockito.mock(SystemConfigProperty.class);
+        Long defaultDayCount = 4L;
+        when(defaultDecayDays.getLongValue()).thenReturn(defaultDayCount);
+        when(defaultConfigManagementService.getDefaultConfig(WarningDecayFeature.DECAY_DAYS_KEY)).thenReturn(defaultDecayDays);
+        when(configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, SERVER_ID, defaultDayCount)).thenReturn(5L);
         List<Warning> warnings = Arrays.asList(firstWarning, secondWarning);
         when(memberService.getMemberInServerAsync(warningUser)).thenReturn(CompletableFuture.completedFuture(warningMember));
         when(memberService.getMemberInServerAsync(firstWarnedUser)).thenReturn(CompletableFuture.completedFuture(warnedMember));

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/listener/ModMailConfigListener.java

@@ -1,36 +0,0 @@
-package dev.sheldan.abstracto.modmail.listener;
-
-import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
-import dev.sheldan.abstracto.modmail.service.ModMailThreadServiceBean;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-import static dev.sheldan.abstracto.modmail.service.ModMailThreadServiceBean.MODMAIL_CLOSING_MESSAGE_TEXT;
-
-/**
- * This listener is used to used to set the initial values of some server specific values, so we don't need to fall
- * back to the default values. The values might not be functional, for example mod mail category id, but their existence
- * makes things easier
- */
-@Component
-@Slf4j
-public class ModMailConfigListener implements ServerConfigListener {
-
-
-    @Autowired
-    private ConfigManagementService configService;
-
-    @Autowired
-    private TemplateService templateService;
-
-    @Override
-    public void updateServerConfig(AServer server) {
-        log.info("Updating modmail related configuration for server {}.", server.getId());
-        configService.loadOrCreateIfNotExists(server.getId(), ModMailThreadServiceBean.MODMAIL_CATEGORY, 0L);
-        configService.loadOrCreateIfNotExists(server.getId(), MODMAIL_CLOSING_MESSAGE_TEXT, templateService.renderSimpleTemplate("modmail_closing_user_message_description"));
-    }
-}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/ResetConfig.java

@@ -0,0 +1,74 @@
+package dev.sheldan.abstracto.core.commands.config;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.config.features.CoreFeatures;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.service.management.FeatureManagementService;
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.exception.ConfigurationKeyNotFoundException;
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class ResetConfig extends AbstractConditionableCommand {
+
+    @Autowired
+    private ConfigService configService;
+
+    @Autowired
+    private DefaultConfigManagementService defaultConfigManagementService;
+
+    @Autowired
+    private FeatureManagementService featureManagementService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        Long serverId = commandContext.getGuild().getIdLong();
+        if(!commandContext.getParameters().getParameters().isEmpty()) {
+            String name = (String) commandContext.getParameters().getParameters().get(0);
+            if(featureManagementService.featureExists(name)) {
+                configService.resetConfigForFeature(name, serverId);
+            } else if(defaultConfigManagementService.configKeyExists(name)) {
+                configService.resetConfigForKey(name, serverId);
+            } else {
+                throw new ConfigurationKeyNotFoundException(name);
+            }
+        } else {
+            configService.resetConfigForServer(serverId);
+        }
+        return CompletableFuture.completedFuture(CommandResult.fromSuccess());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter keyToChange = Parameter.builder().name("key").type(String.class).optional(true).templated(true).build();
+        List<Parameter> parameters = Arrays.asList(keyToChange);
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
+        return CommandConfiguration.builder()
+                .name("resetConfig")
+                .module(ConfigModuleInterface.CONFIG)
+                .parameters(parameters)
+                .templated(true)
+                .async(true)
+                .supportsEmbedException(true)
+                .help(helpInfo)
+                .causesReaction(true)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return CoreFeatures.CORE_FEATURE;
+    }
+
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/SetConfig.java

@@ -21,7 +21,6 @@ public class SetConfig extends AbstractConditionableCommand {
     @Autowired
     private ConfigService configService;
 
-
     @Override
     public CommandResult execute(CommandContext commandContext) {
         String key = (String) commandContext.getParameters().getParameters().get(0);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/config/DefaultConfigProperties.java

@@ -6,10 +6,12 @@ import dev.sheldan.abstracto.core.models.property.PostTargetProperty;
 import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
 import lombok.Getter;
 import lombok.Setter;
+import org.apache.commons.lang3.tuple.Pair;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
 
-import java.util.Map;
+import javax.annotation.PostConstruct;
+import java.util.*;
 
 @Getter
 @Setter
@@ -20,4 +22,26 @@ public class DefaultConfigProperties {
     private Map<String, FeatureFlagProperty> featureFlags;
     private Map<String, PostTargetProperty> postTargets;
     private Map<String, FeatureModeProperty> featureModes;
+
+    /**
+     * This is required to make the keys all lower case, so we can search for them faster, and also make it possible
+     * for users to not require exact names
+     */
+    @PostConstruct
+    public void postConstruct() {
+       makeKeysLowerCase(systemConfigs);
+       makeKeysLowerCase(featureFlags);
+       makeKeysLowerCase(postTargets);
+       makeKeysLowerCase(featureModes);
+    }
+
+    private <T> void makeKeysLowerCase(Map<String, T> map) {
+        Set<String> keys = new HashSet<>(map.keySet());
+        List<Pair<String, T>> pairs = new ArrayList<>();
+        keys.forEach(s ->
+            pairs.add(Pair.of(s.toLowerCase(), map.get(s)))
+        );
+        keys.forEach(map::remove);
+        pairs.forEach(stringTPair -> map.put(stringTPair.getKey(), stringTPair.getValue()));
+    }
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/listener/sync/entity/CoreServiceConfigListener.java

@@ -1,27 +0,0 @@
-package dev.sheldan.abstracto.core.listener.sync.entity;
-
-import dev.sheldan.abstracto.core.command.service.CommandManager;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
-import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-@Slf4j
-public class CoreServiceConfigListener implements ServerConfigListener {
-
-    @Autowired
-    private ConfigManagementService configManagementService;
-
-    @Autowired
-    private DefaultConfigManagementService defaultConfigManagementService;
-
-    @Override
-    public void updateServerConfig(AServer server) {
-        log.info("Creating prefix config for server {}.", server.getId());
-        String defaultPrefix = defaultConfigManagementService.getDefaultConfig(CommandManager.PREFIX).getStringValue();
-        configManagementService.loadOrCreateIfNotExists(server.getId(), CommandManager.PREFIX, defaultPrefix);
-    }
-}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/repository/ConfigRepository.java

@@ -9,9 +9,10 @@ import org.springframework.stereotype.Repository;
 @Repository
 public interface ConfigRepository extends JpaRepository<AConfig, Long> {
 
-    AConfig findAConfigByServerIdAndName(Long serverId, String name);
+    AConfig findAConfigByServerIdAndNameIgnoreCase(Long serverId, String name);
+    void deleteAConfigByServerId(Long serverId);
 
-    boolean existsAConfigByServerIdAndName(Long serverId, String name);
+    boolean existsAConfigByServerIdAndNameIgnoreCase(Long serverId, String name);
 
-    boolean existsAConfigByServerAndName(AServer server, String name);
+    boolean existsAConfigByServerAndNameIgnoreCase(AServer server, String name);
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/repository/FeatureRepository.java

@@ -8,5 +8,5 @@ import org.springframework.stereotype.Repository;
 @Repository
 public interface FeatureRepository extends JpaRepository<AFeature, Long> {
 
-    AFeature findByKey(String key);
+    AFeature findByKeyIgnoreCase(String key);
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ConfigServiceBean.java

@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.core.service;
 
+import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.exception.ConfigurationKeyNotFoundException;
 import dev.sheldan.abstracto.core.models.database.AConfig;
 import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
@@ -17,6 +18,9 @@ public class ConfigServiceBean implements ConfigService {
     @Autowired
     private DefaultConfigManagementService defaultConfigManagementService;
 
+    @Autowired
+    private FeatureConfigService featureConfigService;
+
     @Override
     public Double getDoubleValue(String name, Long serverId) {
        return getDoubleValue(name, serverId, 0D);
@@ -93,7 +97,7 @@ public class ConfigServiceBean implements ConfigService {
     public AConfig setOrCreateConfigValue(String name, Long serverId, String value) {
         if(defaultConfigManagementService.configKeyExists(name)) {
             AConfig fakeConfigValue = getFakeConfigForValue(name, value);
-            return setOrCreateConfigValue(serverId, name, fakeConfigValue);
+            return setOrCreateConfigValue(serverId, fakeConfigValue.getName(), fakeConfigValue);
         } else {
             throw new ConfigurationKeyNotFoundException(name);
         }
@@ -143,8 +147,8 @@ public class ConfigServiceBean implements ConfigService {
     @Override
     public AConfig getFakeConfigForValue(String name, String value) {
         if(defaultConfigManagementService.configKeyExists(name)) {
-            AConfig newConfig = AConfig.builder().name(value).build();
             SystemConfigProperty defaultConfig = defaultConfigManagementService.getDefaultConfig(name);
+            AConfig newConfig = AConfig.builder().name(defaultConfig.getName()).build();
             if(defaultConfig.getDoubleValue() != null) {
                 newConfig.setDoubleValue(Double.parseDouble(value));
             } else if(defaultConfig.getLongValue() != null) {
@@ -157,4 +161,24 @@ public class ConfigServiceBean implements ConfigService {
             throw new ConfigurationKeyNotFoundException(name);
         }
     }
+
+    @Override
+    public void resetConfigForKey(String configKey, Long serverId) {
+        configManagementService.deleteConfig(serverId, configKey);
+    }
+
+    @Override
+    public void resetConfigForFeature(String featureKey, Long serverId) {
+        FeatureConfig featureConfig = featureConfigService.getFeatureDisplayForFeature(featureKey);
+        featureConfig.getRequiredSystemConfigKeys().forEach(s -> {
+            if(configManagementService.configExists(serverId, s)) {
+                resetConfigForKey(s, serverId);
+            }
+        });
+    }
+
+    @Override
+    public void resetConfigForServer(Long serverId) {
+        configManagementService.deleteConfigForServer(serverId);
+    }
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/ConfigManagementServiceBean.java

@@ -121,17 +121,17 @@ public class ConfigManagementServiceBean implements ConfigManagementService {
 
     @Override
     public AConfig loadConfig(Long serverId, String name) {
-        return configRepository.findAConfigByServerIdAndName(serverId, name);
+        return configRepository.findAConfigByServerIdAndNameIgnoreCase(serverId, name);
     }
 
     @Override
     public boolean configExists(Long serverId, String name) {
-        return configRepository.existsAConfigByServerIdAndName(serverId, name);
+        return configRepository.existsAConfigByServerIdAndNameIgnoreCase(serverId, name);
     }
 
     @Override
     public boolean configExists(AServer server, String name) {
-        return configRepository.existsAConfigByServerAndName(server, name);
+        return configRepository.existsAConfigByServerAndNameIgnoreCase(server, name);
     }
 
     @Override
@@ -158,4 +158,15 @@ public class ConfigManagementServiceBean implements ConfigManagementService {
         return config;
     }
 
+    @Override
+    public void deleteConfig(Long serverId, String name) {
+        AConfig config = loadConfig(serverId, name);
+        configRepository.delete(config);
+    }
+
+    @Override
+    public void deleteConfigForServer(Long serverId) {
+        configRepository.deleteAConfigByServerId(serverId);
+    }
+
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/DefaultConfigManagementServiceBean.java

@@ -15,11 +15,11 @@ public class DefaultConfigManagementServiceBean implements DefaultConfigManageme
 
     @Override
     public SystemConfigProperty getDefaultConfig(String key) {
-        return defaultConfigProperties.getSystemConfigs().get(key);
+        return defaultConfigProperties.getSystemConfigs().get(key.toLowerCase());
     }
 
     @Override
     public boolean configKeyExists(String key) {
-        return defaultConfigProperties.getSystemConfigs().containsKey(key);
+        return defaultConfigProperties.getSystemConfigs().containsKey(key.toLowerCase());
     }
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/FeatureManagementServiceBean.java

@@ -32,6 +32,6 @@ public class FeatureManagementServiceBean implements FeatureManagementService {
 
     @Override
     public AFeature getFeature(String key) {
-        return featureRepository.findByKey(key);
+        return featureRepository.findByKeyIgnoreCase(key);
     }
 }

abstracto-application/core/core-impl/src/main/resources/migrations/1.0-core/core-seedData/command.xml

@@ -97,6 +97,12 @@
             <column name="feature_id" valueComputed="${coreFeature}"/>
             <column name="created" valueComputed="${today}"/>
         </insert>
+        <insert tableName="command">
+            <column name="name" value="resetConfig"/>
+            <column name="module_id" valueComputed="${configModule}"/>
+            <column name="feature_id" valueComputed="${coreFeature}"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
         <insert tableName="command">
             <column name="name" value="setPrefix"/>
             <column name="module_id" valueComputed="${configModule}"/>

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/ConfigService.java

@@ -17,5 +17,7 @@ public interface ConfigService {
     void setStringValue(String name, Long serverId, String value);
     boolean configurationIsValid(String name, String value);
     AConfig getFakeConfigForValue(String name, String value);
-
+    void resetConfigForKey(String configKey, Long serverId);
+    void resetConfigForFeature(String featureKey, Long serverId);
+    void resetConfigForServer(Long serverId);
 }

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/management/ConfigManagementService.java

@@ -19,4 +19,6 @@ public interface ConfigManagementService {
     AConfig setDoubleValue(Long serverId, String name, Double value);
     AConfig setLongValue(Long serverId, String name, Long value);
     AConfig setStringValue(Long serverId, String name, String value);
+    void deleteConfig(Long serverId, String name);
+    void deleteConfigForServer(Long serverId);
 }

abstracto-application/documentation/src/main/docs/asciidoc/modules/core.adoc

@@ -18,6 +18,9 @@ Changing the system configuration::
 * Usage `setConfig <key> <value>`
 * Description: Changes the value of this configuration identified by `key` to `value`. Some of these configurations have separate commands, but this works in general.
 * Example: `setConfig expMin 15` to set the minimum experience to 15
+Resetting the configuration to default values::
+* Usage `resetConfig [key/feature]`
+* Description: Resets the configuration of the given `key` or for the complete feature identified by `feature`. If this is not provided, it will reset the entire server to the default configuration.
 Changing emotes Abstracto uses::
 * Usage: `setEmote <key> <emote>`
 * Description: Sets the emote identified by `key` used by Abstracto on this server to `emote`.