mirror of
https://github.com/Sheldan/abstracto.git
synced 2026-06-16 23:33:48 +00:00
[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
This commit is contained in:
Sheldan
@@ -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();
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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 maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId()).intValue();
|
||||
Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getServerId());
|
||||
int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getServerId(), defaultMinExp.getLongValue()).intValue();
|
||||
int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId(), defaultMaxExp.getLongValue()).intValue();
|
||||
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);
|
||||
|
||||
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
private ArgumentCaptor<AUserExperience> aUserExperienceArgumentCaptor;
|
||||
@Mock
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
|
||||
@Mock
|
||||
private AUserExperienceServiceBean self;
|
||||
|
||||
@Mock
|
||||
private ServerManagementService serverManagementService;
|
||||
|
||||
@Mock
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@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();
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
|
||||
Assert.assertEquals(0, calculatedLevel.getLevel().intValue());
|
||||
this.levels = Arrays.asList(level0, level1);
|
||||
setupLevels(1);
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, LOW_EXP);
|
||||
Assert.assertEquals(level0, calculatedLevel);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateLevelBetweenLevels() {
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().experience(250L).build();
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
|
||||
Assert.assertEquals(2, calculatedLevel.getLevel().intValue());
|
||||
this.levels = Arrays.asList(level0, level1, level2);
|
||||
setupLevels(3);
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, MID_EXP);
|
||||
Assert.assertEquals(level2, calculatedLevel);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateLevelTooHigh() {
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().experience(500L).build();
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
|
||||
Assert.assertEquals(3, calculatedLevel.getLevel().intValue());
|
||||
this.levels = Arrays.asList(level0, level1, level2, level3);
|
||||
setupLevels(3);
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, HIGH_EXP);
|
||||
Assert.assertEquals(level3, calculatedLevel);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateUserExperienceLevelChanged() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(1)).experience(250L).build();
|
||||
Assert.assertTrue(testUnit.updateUserLevel(experienceToCalculate, levels, experienceToCalculate.getExperience()));
|
||||
AUserExperience experienceToCalculate = Mockito.mock(AUserExperience.class);
|
||||
when(experienceToCalculate.getUser()).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
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();
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(2)).experience(250L).build();
|
||||
AUserExperience experienceToCalculate = Mockito.mock(AUserExperience.class);
|
||||
when(experienceToCalculate.getCurrentLevel()).thenReturn(level2);
|
||||
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);
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(roleService.removeRoleFromUserFuture(userExperience.getUser(), userExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
setupServerId();
|
||||
setupLevels(3);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
AExperienceRole previousExperienceRole = experienceRole1;
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, previousExperienceRole.getRole());
|
||||
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
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, 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(servers).join();
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
|
||||
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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
AExperienceRole newRole = experienceRoles.get(1);
|
||||
setupServerId();
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
setupServerConfig();
|
||||
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(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newRole.getRole());
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
|
||||
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHandleExperienceForUserNotLevelingUpWithoutExistingRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = null;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = experienceRoles.get(1);
|
||||
setupServerId();
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(null);
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
AExperienceRole newRole = experienceRole1;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
setupTwoExperienceRoles();
|
||||
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));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = null;
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(50L);
|
||||
setExperienceRoleLevels();
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = null;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(null);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(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)).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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(50L);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(0);
|
||||
AExperienceRole previousExperienceRole = experienceRole1;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = null;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
|
||||
when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setExperienceRoleLevels();
|
||||
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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
ServerExperience serverToUse = servers.get(0);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
mockSimpleServer(levels, experienceRoles, serverToUse);
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
|
||||
setupServerId();
|
||||
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
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();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
setupServerId();
|
||||
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);
|
||||
CompletableFuture<Void> future = testUnit.handleExperienceGain(servers);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
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(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
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);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
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(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(roleService.removeRoleFromUserFuture(aUserInAServer, beforeRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(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);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
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(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
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);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
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(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.memberHasRole(firstMember, SECOND_ROLE_ID)).thenReturn(false);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, ROLE_ID)).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 = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
|
||||
when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
|
||||
testUnit.disableExperienceForUser(userObject);
|
||||
Assert.assertTrue(experience.getExperienceGainDisabled());
|
||||
AUserExperience experience = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
|
||||
testUnit.disableExperienceForUser(aUserInAServer);
|
||||
verify(experience, times(1)).setExperienceGainDisabled(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDisablingExpForUserWhichHasItDisabled() {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, server);
|
||||
AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
|
||||
when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
|
||||
testUnit.disableExperienceForUser(userObject);
|
||||
Assert.assertTrue(experience.getExperienceGainDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEnablingExperienceForEnabledUser() {
|
||||
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());
|
||||
public void testEnablingExpForUser() {
|
||||
AUserExperience experience = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
|
||||
testUnit.enableExperienceForUser(aUserInAServer);
|
||||
verify(experience, times(1)).setExperienceGainDisabled(false);
|
||||
}
|
||||
|
||||
@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);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
|
||||
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(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(memberService.getMemberInServerAsync(userExperience2.getUser())).thenReturn(CompletableFuture.completedFuture(secondMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.memberHasRole(secondMember, afterRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
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(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
|
||||
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)).addRoleToMemberFuture(secondMember, afterRole.getRole().getId());
|
||||
verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, ROLE_ID);
|
||||
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);
|
||||
AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
|
||||
AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
|
||||
when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(experienceObj);
|
||||
LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
|
||||
.builder()
|
||||
.experience(experience)
|
||||
.id(1L)
|
||||
.level(level)
|
||||
.messageCount(messageCount)
|
||||
.rank(rank)
|
||||
.userInServerId(1L)
|
||||
.build();
|
||||
AUserExperience experienceObj = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experienceObj);
|
||||
LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
|
||||
when(leaderBoardEntryTest.getRank()).thenReturn(rank);
|
||||
when(userExperienceManagementService.getRankOfUserInServer(experienceObj)).thenReturn(leaderBoardEntryTest);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
|
||||
Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
|
||||
Assert.assertEquals(experienceObj, rankOfUserInServer.getExperience());
|
||||
Assert.assertEquals(rank, rankOfUserInServer.getRank().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRankForUserNotExisting() {
|
||||
AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
|
||||
when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(null);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(null);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
|
||||
Assert.assertNull(rankOfUserInServer.getExperience());
|
||||
Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRankWhenRankReturnsNull() {
|
||||
long experience = 1L;
|
||||
int level = 1;
|
||||
long messageCount = 1L;
|
||||
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);
|
||||
AUserExperience experienceObj = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experienceObj);
|
||||
when(userExperienceManagementService.getRankOfUserInServer(experienceObj)).thenReturn(null);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
|
||||
Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
|
||||
Assert.assertEquals(messageCount, rankOfUserInServer.getExperience().getMessageCount().longValue());
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
|
||||
Assert.assertEquals(experienceObj, rankOfUserInServer.getExperience());
|
||||
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 entry = entries.get(i);
|
||||
Assert.assertEquals(i, entry.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(i, entry.getExperience().getCurrentLevel().getLevel().intValue());
|
||||
Assert.assertEquals(i, entry.getExperience().getUser().getUserReference().getId().longValue());
|
||||
Assert.assertEquals((page * pageSize) + i + 1, entry.getRank().intValue());
|
||||
}
|
||||
Assert.assertEquals(pageSize, entries.size());
|
||||
LeaderBoardEntry firstEntry = entries.get(0);
|
||||
Assert.assertEquals(LOW_EXP, firstEntry.getExperience().getExperience());
|
||||
Assert.assertEquals(level0, firstEntry.getExperience().getCurrentLevel());
|
||||
Assert.assertEquals(aUserInAServer, firstEntry.getExperience().getUser());
|
||||
Assert.assertEquals((page * pageSize) + 1, firstEntry.getRank().intValue());
|
||||
LeaderBoardEntry secondEntry = entries.get(1);
|
||||
Assert.assertEquals(MID_EXP, secondEntry.getExperience().getExperience());
|
||||
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) {
|
||||
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);
|
||||
when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
|
||||
private void setExperienceRoleLevels() {
|
||||
when(experienceRole1.getLevel()).thenReturn(level0);
|
||||
when(experienceRole2.getLevel()).thenReturn(level1);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
.builder()
|
||||
.experience(experienceValue)
|
||||
.build();
|
||||
LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
|
||||
when(leaderBoardEntryTest.getExperience()).thenReturn(experienceValue);
|
||||
when(repository.getRankOfUserInServer(experience.getId(), server.getId())).thenReturn(leaderBoardEntryTest);
|
||||
LeaderBoardEntryResult rankOfUserInServer = testUnit.getRankOfUserInServer(experience);
|
||||
Assert.assertEquals(experienceValue, rankOfUserInServer.getExperience().longValue());
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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) {
|
||||
Long days = configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId());
|
||||
public CompletableFuture<Void> decayWarningsForServer(AServer server) {
|
||||
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);
|
||||
|
||||
@@ -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.Captor;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.*;
|
||||
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));
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user