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

[AB-165] removing mocking utils and general test improvements

Browse Source
This commit is contained in:
Sheldan
2021-02-28 21:46:45 +01:00
parent 5f6746d742
commit 821971523e
55 changed files with 834 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -123,7 +123,7 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
if(roles == null || roles.isEmpty()) {
return null;
}
log.trace("Calculating role for level {} in server {}. Using {} roles in our config.", currentLevel, roles.get(0).getRoleServer().getId(), roles.size());
log.trace("Calculating role for level {} in server {}. Using {} roles in our config.", currentLevel, roles.get(0).getServer().getId(), roles.size());
AExperienceRole lastRole = null;
for (AExperienceRole experienceRole : roles) {
if(currentLevel >= experienceRole.getLevel().getLevel()) {

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

@@ -38,7 +38,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
@Override
public void unsetRole(AExperienceRole role) {
log.info("Deleting experience role {} in server {}.", role.getId(), role.getRoleServer().getId());
log.info("Deleting experience role {} in server {}.", role.getId(), role.getServer().getId());
experienceRoleRepository.delete(role);
}
@@ -93,7 +93,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
.builder()
.id(role.getId())
.level(level)
.roleServer(role.getServer())
.server(role.getServer())
.role(role)
.build();
log.trace("Role did not exist. Creating new.");

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

@@ -75,7 +75,7 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
@Override
public LeaderBoardEntryResult getRankOfUserInServer(AUserExperience userExperience) {
return repository.getRankOfUserInServer(userExperience.getId(), userExperience.getUser().getServerReference().getId());
return repository.getRankOfUserInServer(userExperience.getId(), userExperience.getServer().getId());
}
@Override

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

@@ -75,11 +75,11 @@ public class LeaderBoardCommandTest {
when(userInServerManagementService.loadOrCreateUser(context.getAuthor())).thenReturn(userInAServer);
when(userExperienceService.findLeaderBoardData(server, expectedPage)).thenReturn(leaderBoard);
when(converter.fromLeaderBoard(leaderBoard)).thenReturn(new ArrayList<>());
LeaderBoardEntry executingUserRank = LeaderBoardEntry.builder().build();
LeaderBoardEntry executingUserRank = Mockito.mock(LeaderBoardEntry.class);
when(userExperienceService.getRankOfUserInServer(userInAServer)).thenReturn(executingUserRank);
LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
LeaderBoardEntryModel leaderBoardEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
MessageToSend messageToSend = MessageToSend.builder().build();
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(LeaderBoardCommand.LEADER_BOARD_POST_EMBED_TEMPLATE), any(LeaderBoardModel.class), eq(SERVER_ID))).thenReturn(messageToSend);
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
verify(channelService, times(1)).sendMessageToSendToChannel(messageToSend, context.getChannel());

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

@@ -7,7 +7,6 @@ import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
@@ -62,8 +61,8 @@ public class ListDisabledExperienceRolesTest {
public void testCommandExecutionRolesFound() {
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = Mockito.mock(AServer.class);
ADisabledExpRole disabledExpRole1 = ADisabledExpRole.builder().role(MockUtils.getRole(4L, server)).build();
ADisabledExpRole disabledExpRole2 = ADisabledExpRole.builder().role(MockUtils.getRole(6L, server)).build();
ADisabledExpRole disabledExpRole1 = Mockito.mock(ADisabledExpRole.class);
ADisabledExpRole disabledExpRole2 = Mockito.mock(ADisabledExpRole.class);
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(Arrays.asList(disabledExpRole1, disabledExpRole2));
Role role1 = Mockito.mock(Role.class);
Role role2 = Mockito.mock(Role.class);

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

@@ -1,12 +1,11 @@
package dev.sheldan.abstracto.experience.converter;
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.MemberService;
import dev.sheldan.abstracto.core.test.MockUtils;
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;
@@ -34,66 +33,67 @@ public class LeaderBoardModelConverterTest {
@Mock
private MemberService memberService;
private static final Long SERVER_ID = 4L;
private static final Long USER_ID = 5L;
private static final Long USER_ID_2 = 6L;
@Test
public void testFromLeaderBoard() {
AServer server = MockUtils.getServer();
int firstRank = 1;
int firstExperience = 1;
LeaderBoardEntry entry = getEntry(server, firstExperience, firstRank);
int secondRank = 2;
int secondExperience = 2;
LeaderBoardEntry entry2 = getEntry(server, secondExperience, secondRank);
Integer firstRank = 1;
Long firstExperience = 1L;
LeaderBoardEntry entry = getEntry(firstExperience, firstRank, USER_ID);
Integer secondRank = 2;
Long secondExperience = 2L;
LeaderBoardEntry entry2 = getEntry(secondExperience, secondRank, USER_ID_2);
List<LeaderBoardEntry> entries = Arrays.asList(entry, entry2);
LeaderBoard leaderBoard = LeaderBoard.builder().entries(entries).build();
LeaderBoard leaderBoard = Mockito.mock(LeaderBoard.class);
when(leaderBoard.getEntries()).thenReturn(entries);
Member member = Mockito.mock(Member.class);
when(memberService.getMemberInServerAsync(server.getId(), entry.getExperience().getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(server.getId(), entry2.getExperience().getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID_2)).thenReturn(CompletableFuture.completedFuture(member));
List<CompletableFuture<LeaderBoardEntryModel>> leaderBoardEntryModels = testUnit.fromLeaderBoard(leaderBoard);
LeaderBoardEntryModel firstEntry = leaderBoardEntryModels.get(0).join();
Assert.assertEquals(firstRank, firstEntry.getRank().intValue());
Assert.assertEquals(firstExperience, firstEntry.getExperience().getExperience().longValue());
Assert.assertEquals(firstRank, firstEntry.getRank());
Assert.assertEquals(firstExperience, firstEntry.getExperience().getExperience());
LeaderBoardEntryModel secondEntry = leaderBoardEntryModels.get(1).join();
Assert.assertEquals(secondRank, secondEntry.getRank().intValue());
Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience().longValue());
Assert.assertEquals(secondRank, secondEntry.getRank());
Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience());
Assert.assertEquals(entries.size(), leaderBoardEntryModels.size());
}
@Test
public void testFromEntry() {
AServer server = MockUtils.getServer();
Long userId = 3L;
AUserExperience experience = getUserExperienceObject(server, userId);
LeaderBoardEntry entry = LeaderBoardEntry.builder().experience(experience).rank(1).build();
Integer rank = 2;
LeaderBoardEntry entry = getEntry(1L, rank, USER_ID);
Member member = Mockito.mock(Member.class);
User user = Mockito.mock(User.class);
when(user.getIdLong()).thenReturn(userId);
when(user.getIdLong()).thenReturn(USER_ID);
when(member.getUser()).thenReturn(user);
when(memberService.getMemberInServerAsync(server.getId(), experience.getUser().getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(member));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
CompletableFuture<LeaderBoardEntryModel> leaderBoardEntryModel = testUnit.fromLeaderBoardEntry(entry);
LeaderBoardEntryModel entryModel = leaderBoardEntryModel.join();
Assert.assertEquals(1, entryModel.getRank().intValue());
Assert.assertEquals(experience.getUser().getUserReference().getId(), entryModel.getExperience().getUser().getUserReference().getId());
Assert.assertEquals(experience.getUser().getUserReference().getId().longValue(), entryModel.getMember().getUser().getIdLong());
Assert.assertEquals(rank, entryModel.getRank());
Assert.assertEquals(USER_ID, entryModel.getExperience().getUser().getUserReference().getId());
Assert.assertEquals(USER_ID.longValue(), entryModel.getMember().getUser().getIdLong());
}
private LeaderBoardEntry getEntry(AServer server, Integer experienceParameter, Integer rank) {
AUserExperience firstExperience = getUserExperienceObject(server, experienceParameter);
return LeaderBoardEntry.builder().rank(rank).experience(firstExperience).build();
private LeaderBoardEntry getEntry(Long experienceCount, Integer rank, Long userId) {
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(experience.getExperience()).thenReturn(experienceCount);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(experience.getUser()).thenReturn(userInAServer);
AUser user = Mockito.mock(AUser.class);
when(userInAServer.getUserReference()).thenReturn(user);
when(user.getId()).thenReturn(userId);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(userInAServer.getServerReference()).thenReturn(server);
LeaderBoardEntry entry = Mockito.mock(LeaderBoardEntry.class);
when(entry.getRank()).thenReturn(rank);
when(entry.getExperience()).thenReturn(experience);
return entry;
}
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();
}
}

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

@@ -7,7 +7,6 @@ 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.config.features.ExperienceFeatureConfig;
import dev.sheldan.abstracto.experience.models.LeaderBoard;
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
@@ -315,6 +314,7 @@ public class AUserExperienceServiceBeanTest {
future.join();
Assert.assertFalse(future.isCompletedExceptionally());
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).removeRoleFromUserFuture(any(AUserInAServer.class), any());
verify(self, times(1)).persistExperienceChanges(anyList());
}
@@ -332,8 +332,8 @@ public class AUserExperienceServiceBeanTest {
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).removeRoleFromUserFuture(any(AUserInAServer.class), any());
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any());
verify(self, times(1)).persistExperienceChanges(anyList());
}
@@ -388,7 +388,9 @@ public class AUserExperienceServiceBeanTest {
setupDefaultConfig();
setupLevelsAndRolesAndNoDisallowed();
setExperienceRoleLevels();
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
CompletableFuture<Void> future = testUnit.handleExperienceGain(Arrays.asList(serverExperience));
future.join();
Assert.assertFalse(future.isCompletedExceptionally());
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
verify(self, times(1)).persistExperienceChanges(anyList());

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

@@ -36,7 +36,9 @@ public class ExperienceLevelServiceBeanTest {
@Test
public void testExperienceToNextLevelCalculation() {
when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.of(AExperienceLevel.builder().level(51).experienceNeeded(15L).build()));
AExperienceLevel level = mock(AExperienceLevel.class);
when(level.getExperienceNeeded()).thenReturn(15L);
when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.of(level));
Long experience = testingUnit.calculateExperienceToNextLevel(50, 10L);
Assert.assertEquals(5L, experience.longValue());
}

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

@@ -1,7 +1,6 @@
package dev.sheldan.abstracto.experience.service;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelType;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
@@ -58,30 +57,30 @@ public class ExperienceRoleServiceBeanTest {
private AServer server;
private static final Long CHANNEL_ID = 4L;
private static final Long ROLE_ID = 5L;
@Test
public void testSettingRoleToLevelWithoutOldUsers() {
Integer levelCount = 10;
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
Role roleToChange = Mockito.mock(Role.class);
ARole role = Mockito.mock(ARole.class);
Long roleId = 5L;
when(roleToChange.getIdLong()).thenReturn(roleId);
when(roleManagementService.findRole(roleId)).thenReturn(role);
AExperienceRole previousExperienceRole = AExperienceRole.builder().role(role).roleServer(server).level(level).build();
when(roleToChange.getIdLong()).thenReturn(ROLE_ID);
when(roleManagementService.findRole(ROLE_ID)).thenReturn(role);
AExperienceRole previousExperienceRole = Mockito.mock(AExperienceRole.class);
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
future.join();
verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
verify(self, times(1)).unsetRoleInDb(levelCount, roleId);
verify(self, times(1)).unsetRoleInDb(levelCount, ROLE_ID);
}
@Test
public void testUnsetRoleInDb() {
Integer levelCount = 10;
AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
ARole roleToChange = getRole(1L, server);
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
ARole roleToChange = Mockito.mock(ARole.class);
when(roleToChange.getServer()).thenReturn(server);
when(experienceLevelService.getLevel(levelCount)).thenReturn(Optional.of(level));
when(roleManagementService.findRole(roleToChange.getId())).thenReturn(roleToChange);
testingUnit.unsetRoleInDb(levelCount, roleToChange.getId());
@@ -95,19 +94,17 @@ public class ExperienceRoleServiceBeanTest {
@Test
public void testSettingRoleToLevelExistingUsers() {
Integer levelCount = 10;
AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
Role roleToChange = Mockito.mock(Role.class);
ARole role = Mockito.mock(ARole.class);
Long roleId = 5L;
when(roleToChange.getIdLong()).thenReturn(roleId);
when(roleManagementService.findRole(roleId)).thenReturn(role);
when(roleToChange.getIdLong()).thenReturn(ROLE_ID);
when(roleManagementService.findRole(ROLE_ID)).thenReturn(role);
when(role.getServer()).thenReturn(server);
ARole newRoleToAward = getRole(2L, server);
AUserExperience firstUser = AUserExperience.builder().build();
AUserExperience secondUser = AUserExperience.builder().build();
AUserExperience firstUser = Mockito.mock(AUserExperience.class);
AUserExperience secondUser = Mockito.mock(AUserExperience.class);
List<AUserExperience> users = Arrays.asList(firstUser, secondUser);
AExperienceRole previousExperienceRole = AExperienceRole.builder().role(role).id(roleToChange.getIdLong()).roleServer(server).level(level).users(users).build();
AExperienceRole newExperienceRole = AExperienceRole.builder().role(newRoleToAward).id(newRoleToAward.getId()).roleServer(server).level(level).build();
AExperienceRole previousExperienceRole = Mockito.mock(AExperienceRole.class);
when(previousExperienceRole.getUsers()).thenReturn(users);
AExperienceRole newExperienceRole = Mockito.mock(AExperienceRole.class);
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(new ArrayList<>(Arrays.asList(newExperienceRole, previousExperienceRole)));
List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
@@ -124,55 +121,55 @@ public class ExperienceRoleServiceBeanTest {
@Test
public void testCalculateRoleForLevelInBetween() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 7);
Assert.assertEquals(5, aExperienceRole.getLevel().getLevel().intValue());
}
@Test
public void testCalculateRoleForLevelBelow() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(4).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 4);
Assert.assertNull(aExperienceRole);
}
@Test
public void testCalculateRoleForLevelOver() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(11).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 11);
Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
}
@Test
public void testCalculateRoleForLevelExact() {
List<AExperienceRole> roles = getExperienceRoles();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(10).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
Integer level = 10;
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, level);
Assert.assertEquals(level, aExperienceRole.getLevel().getLevel());
}
@Test
public void testCalculateRoleForNoRoleConfigFound() {
List<AExperienceRole> roles = new ArrayList<>();
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, 10);
Assert.assertNull(aExperienceRole);
}
@Test
public void testCalculatingLevelOfNextRole() {
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(getExperienceRoles());
AExperienceLevel levelToCheckFor = AExperienceLevel.builder().level(7).build();
List<AExperienceRole> experienceRoles = getExperienceRoles();
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
AExperienceLevel levelToCheckFor = Mockito.mock(AExperienceLevel.class);
when(levelToCheckFor.getLevel()).thenReturn(7);
AExperienceLevel levelOfNextRole = testingUnit.getLevelOfNextRole(levelToCheckFor, server);
Assert.assertEquals(10, levelOfNextRole.getLevel().intValue());
}
@Test
public void testCalculatingLevelOfNextRoleIfThereIsNone() {
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(getExperienceRoles());
AExperienceLevel levelToCheckFor = AExperienceLevel.builder().level(15).build();
List<AExperienceRole> experienceRoles = getExperienceRoles();
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
AExperienceLevel levelToCheckFor = Mockito.mock(AExperienceLevel.class);
when(levelToCheckFor.getLevel()).thenReturn(15);
AExperienceLevel levelOfNextRole = testingUnit.getLevelOfNextRole(levelToCheckFor, server);
Assert.assertEquals(200, levelOfNextRole.getLevel().intValue());
}
@@ -180,20 +177,16 @@ public class ExperienceRoleServiceBeanTest {
private List<AExperienceRole> getExperienceRoles() {
AExperienceRole level5ExperienceRole = getExperienceRoleForLevel(5);
AExperienceRole level10ExperienceRole = getExperienceRoleForLevel(10);
when(level5ExperienceRole.getServer()).thenReturn(server);
return Arrays.asList(level5ExperienceRole, level10ExperienceRole);
}
private AExperienceRole getExperienceRoleForLevel(int levelToBuild) {
AExperienceLevel firstLevel = AExperienceLevel.builder().level(levelToBuild).build();
return AExperienceRole.builder().roleServer(server).level(firstLevel).build();
}
private ARole getRole(Long id, AServer server) {
return ARole.builder().id(id).server(server).deleted(false).build();
}
private AChannel getFeedbackChannel(AServer server) {
return AChannel.builder().id(1L).server(server).type(AChannelType.TEXT).build();
private AExperienceRole getExperienceRoleForLevel(int level) {
AExperienceLevel experienceLevel = Mockito.mock(AExperienceLevel.class);
when(experienceLevel.getLevel()).thenReturn(level);
AExperienceRole role = Mockito.mock(AExperienceRole.class);
when(role.getLevel()).thenReturn(experienceLevel);
return role;
}
}

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

@@ -9,6 +9,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.*;
@@ -24,17 +25,20 @@ public class DisabledExpRoleManagementServiceBeanTest {
@Test
public void testRoleToSetDisabled() {
ARole role = getARole();
ADisabledExpRole createdDisabledRole = getDisabledRole(role);
ARole role = Mockito.mock(ARole.class);
AServer server = Mockito.mock(AServer.class);
when(role.getServer()).thenReturn(server);
ADisabledExpRole createdDisabledRole = Mockito.mock(ADisabledExpRole.class);
when(createdDisabledRole.getRole()).thenReturn(role);
when(disabledExpRoleRepository.save(any(ADisabledExpRole.class))).thenReturn(createdDisabledRole);
ADisabledExpRole aDisabledExpRole = testUnit.setRoleToBeDisabledForExp(role);
Assert.assertEquals(role.getId(), aDisabledExpRole.getRole().getId());
Assert.assertEquals(createdDisabledRole.getId(), aDisabledExpRole.getId());
Assert.assertEquals(role, aDisabledExpRole.getRole());
Assert.assertEquals(createdDisabledRole, aDisabledExpRole);
}
@Test
public void testIfRoleIsDisabled() {
ARole aRole = getARole();
ARole aRole = Mockito.mock(ARole.class);
when(disabledExpRoleRepository.existsByRole(aRole)).thenReturn(true);
boolean experienceDisabledForRole = testUnit.isExperienceDisabledForRole(aRole);
Assert.assertTrue(experienceDisabledForRole);
@@ -43,24 +47,16 @@ public class DisabledExpRoleManagementServiceBeanTest {
@Test
public void testRemoveRoleFromDisabled() {
ARole aRole = getARole();
ARole aRole = Mockito.mock(ARole.class);
testUnit.removeRoleToBeDisabledForExp(aRole);
verify(disabledExpRoleRepository, times(1)).deleteByRole(aRole);
}
@Test
public void testRetrieveAllDisabledRolesForServer() {
AServer server = AServer.builder().id(1L).build();
AServer server = Mockito.mock(AServer.class);
testUnit.getDisabledRolesForServer(server);
verify(disabledExpRoleRepository, times(1)).getByRole_Server(server);
}
private ADisabledExpRole getDisabledRole(ARole role) {
return ADisabledExpRole.builder().role(role).id(2L).build();
}
private ARole getARole() {
AServer server = AServer.builder().id(4L).build();
return ARole.builder().id(1L).server(server).build();
}
}

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

@@ -7,6 +7,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -29,7 +30,9 @@ public class ExperienceLevelManagementServiceBeanTest {
public void testCreateExperienceLevel() {
Integer level = 1;
Long neededExperience = 100L;
AExperienceLevel createdLevel = getLevel(level, neededExperience);
AExperienceLevel createdLevel = Mockito.mock(AExperienceLevel.class);
when(createdLevel.getLevel()).thenReturn(level);
when(createdLevel.getExperienceNeeded()).thenReturn(neededExperience);
when(experienceLevelRepository.save(any(AExperienceLevel.class))).thenReturn(createdLevel);
AExperienceLevel experienceLevel = testUnit.createExperienceLevel(level, neededExperience);
Assert.assertEquals(experienceLevel.getLevel(), createdLevel.getLevel());
@@ -47,8 +50,10 @@ public class ExperienceLevelManagementServiceBeanTest {
public void testFindLevel() {
int levelValue = 1;
long experienceAmount = 100L;
Optional<AExperienceLevel> level = Optional.of(getLevel(levelValue, experienceAmount));
when(experienceLevelRepository.findById(levelValue)).thenReturn(level);
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
when(level.getLevel()).thenReturn(levelValue);
when(level.getExperienceNeeded()).thenReturn(experienceAmount);
when(experienceLevelRepository.findById(levelValue)).thenReturn(Optional.of(level));
Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevel(levelValue);
Assert.assertTrue(foundLevelOptional.isPresent());
if(foundLevelOptional.isPresent()) {
@@ -71,8 +76,12 @@ public class ExperienceLevelManagementServiceBeanTest {
@Test
public void findAllLevelConfigurations() {
AExperienceLevel availableLevel = getLevel(1, 100L);
AExperienceLevel availableLevel2 = getLevel(2, 200L);
AExperienceLevel availableLevel = Mockito.mock(AExperienceLevel.class);
when(availableLevel.getLevel()).thenReturn(1);
when(availableLevel.getExperienceNeeded()).thenReturn(100L);
AExperienceLevel availableLevel2 = Mockito.mock(AExperienceLevel.class);
when(availableLevel2.getLevel()).thenReturn(2);
when(availableLevel2.getExperienceNeeded()).thenReturn(200L);
List<AExperienceLevel> levelConfig = Arrays.asList(availableLevel, availableLevel2);
when(experienceLevelRepository.findAll()).thenReturn(levelConfig);
List<AExperienceLevel> foundLevelConfig = testUnit.getLevelConfig();
@@ -84,11 +93,4 @@ public class ExperienceLevelManagementServiceBeanTest {
Assert.assertEquals(2, secondLevelConfig.getLevel().intValue());
}
private AExperienceLevel getLevel(Integer level, Long neededExperience) {
return AExperienceLevel
.builder()
.level(level)
.experienceNeeded(neededExperience)
.build();
}
}

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

@@ -2,17 +2,13 @@ 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.models.database.AExperienceLevel;
import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
import dev.sheldan.abstracto.experience.repository.ExperienceRoleRepository;
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.util.ArrayList;
@@ -35,29 +31,39 @@ public class ExperienceRoleManagementServiceBeanTest {
@Captor
private ArgumentCaptor<AExperienceRole> roleArgumentCaptor;
@Mock
private AExperienceRole experienceRole;
@Mock
private ARole role;
@Mock
private AServer server;
@Mock
private AExperienceLevel level;
private static final Long SERVER_ID = 3L;
private static final Long ROLE_ID = 4L;
@Test
public void testRemovingAllRoleAssignmentsForLevel() {
AServer server = MockUtils.getServer();
AExperienceLevel level = getLevel(10, 100L);
List<AExperienceRole> experienceRoles = getExperienceRoles();
when(level.getLevel()).thenReturn(10);
AExperienceRole secondRole = Mockito.mock(AExperienceRole.class);
List<AExperienceRole> experienceRoles = Arrays.asList(experienceRole, secondRole);
when(experienceRoleRepository.findByLevelAndRoleServer(level, server)).thenReturn(experienceRoles);
testUnit.removeAllRoleAssignmentsForLevelInServer(level, server);
verify(experienceRoleRepository, times(1)).findByLevelAndRoleServer(level, server);
verify(experienceRoleRepository, times(experienceRoles.size())).delete(roleArgumentCaptor.capture());
List<AExperienceRole> allValues = roleArgumentCaptor.getAllValues();
for (int i = 0; i < allValues.size(); i++) {
AExperienceRole role = allValues.get(i);
AExperienceRole innerRole = experienceRoles.get(i);
Assert.assertEquals(innerRole.getLevel().getLevel(), role.getLevel().getLevel());
Assert.assertEquals(innerRole.getRole().getId(), role.getRole().getId());
}
Assert.assertEquals(experienceRole, allValues.get(0));
Assert.assertEquals(secondRole, allValues.get(1));
Assert.assertEquals(2, allValues.size());
}
@Test
public void removeRoleAssignmentsForLevelWithoutAny() {
AServer server = MockUtils.getServer();
AExperienceLevel level = getLevel(10, 100L);
when(level.getLevel()).thenReturn(10);
List<AExperienceRole> experienceRoles = new ArrayList<>();
when(experienceRoleRepository.findByLevelAndRoleServer(level, server)).thenReturn(experienceRoles);
testUnit.removeAllRoleAssignmentsForLevelInServer(level, server);
@@ -69,79 +75,61 @@ public class ExperienceRoleManagementServiceBeanTest {
@Test
public void testUnsetRole() {
AExperienceRole role = getExperienceRoleForLevel(37);
testUnit.unsetRole(role);
verify(experienceRoleRepository, times(1)).delete(role);
when(experienceRole.getServer()).thenReturn(server);
testUnit.unsetRole(experienceRole);
verify(experienceRoleRepository, times(1)).delete(experienceRole);
}
@Test
public void testFindExperienceRoleForRoleInServer() {
AExperienceRole expRole = getExperienceRoleForLevel(37);
when((experienceRoleRepository.findByRole(expRole.getRole()))).thenReturn(Optional.of(expRole));
AExperienceRole roleInServer = testUnit.getRoleInServer(expRole.getRole());
Assert.assertEquals(expRole.getRole().getId(), roleInServer.getRole().getId());
verify(experienceRoleRepository, times(1)).findByRole(expRole.getRole());
when((experienceRoleRepository.findByRole(role))).thenReturn(Optional.of(experienceRole));
AExperienceRole roleInServer = testUnit.getRoleInServer(role);
Assert.assertEquals(experienceRole, roleInServer);
}
@Test
public void testFindExperienceRolesForServer() {
AServer server = MockUtils.getServer();
List<AExperienceRole> experienceRoles = getExperienceRoles();
AExperienceRole secondRole = Mockito.mock(AExperienceRole.class);
List<AExperienceRole> experienceRoles = Arrays.asList(experienceRole, secondRole);
when(experienceRoleRepository.findByRoleServer(server)).thenReturn(experienceRoles);
List<AExperienceRole> experienceRolesForServer = testUnit.getExperienceRolesForServer(server);
verify(experienceRoleRepository, times(1)).findByRoleServer(server);
for (int i = 0; i < experienceRolesForServer.size(); i++) {
AExperienceRole role = experienceRolesForServer.get(i);
AExperienceRole innerRole = experienceRoles.get(i);
Assert.assertEquals(innerRole.getLevel().getLevel(), role.getLevel().getLevel());
Assert.assertEquals(innerRole.getRole().getId(), role.getRole().getId());
}
Assert.assertEquals(experienceRole, experienceRolesForServer.get(0));
Assert.assertEquals(secondRole, experienceRolesForServer.get(1));
Assert.assertEquals(2, experienceRolesForServer.size());
}
@Test
public void setLevelToRoleWhichHasAnExistingMapping() {
int level = 5;
AExperienceRole experienceRole = getExperienceRoleForLevel(level);
when(experienceRoleRepository.findByRole(experienceRole.getRole())).thenReturn(Optional.of(experienceRole));
AExperienceLevel newLevel = AExperienceLevel.builder().level(8).build();
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, experienceRole.getRole());
verify(experienceRoleRepository, times(1)).findByRole(experienceRole.getRole());
Assert.assertEquals(newLevel.getLevel(), updatedExperienceRole.getLevel().getLevel());
Integer levelNumber = 4;
setupExperienceRole(levelNumber);
when(experienceRoleRepository.findByRole(role)).thenReturn(Optional.of(experienceRole));
AExperienceLevel newLevel = Mockito.mock(AExperienceLevel.class);
when(newLevel.getLevel()).thenReturn(levelNumber);
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, role);
verify(experienceRoleRepository, times(1)).findByRole(role);
Assert.assertEquals(levelNumber, updatedExperienceRole.getLevel().getLevel());
}
@Test
public void setLevelToRoleWithoutAMappingExistingPreviously() {
int level = 5;
AExperienceRole experienceRole = getExperienceRoleForLevel(level);
Integer levelNumber = 4;
setupExperienceRole(levelNumber);
when(experienceRoleRepository.findByRole(experienceRole.getRole())).thenReturn(Optional.empty());
when(experienceRoleRepository.save(any(AExperienceRole.class))).thenReturn(experienceRole);
AExperienceLevel newLevel = AExperienceLevel.builder().level(8).build();
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, experienceRole.getRole());
verify(experienceRoleRepository, times(1)).findByRole(experienceRole.getRole());
Assert.assertEquals(experienceRole.getLevel().getLevel(), updatedExperienceRole.getLevel().getLevel());
AExperienceLevel newLevel = Mockito.mock(AExperienceLevel.class);
AExperienceRole updatedExperienceRole = testUnit.setLevelToRole(newLevel, role);
verify(experienceRoleRepository, times(1)).findByRole(role);
Assert.assertEquals(levelNumber, updatedExperienceRole.getLevel().getLevel());
}
private List<AExperienceRole> getExperienceRoles() {
AExperienceRole level5ExperienceRole = getExperienceRoleForLevel(7);
AExperienceRole level10ExperienceRole = getExperienceRoleForLevel(25);
return Arrays.asList(level5ExperienceRole, level10ExperienceRole);
}
private AExperienceRole getExperienceRoleForLevel(int levelToBuild) {
AExperienceLevel firstLevel = AExperienceLevel.builder().level(levelToBuild).build();
AServer server = AServer.builder().id(4L).build();
ARole aRole = ARole.builder().id((long) levelToBuild).server(server).build();
return AExperienceRole.builder().role(aRole).roleServer(server).level(firstLevel).build();
}
private AExperienceLevel getLevel(Integer level, Long neededExperience) {
return AExperienceLevel
.builder()
.level(level)
.experienceNeeded(neededExperience)
.build();
private void setupExperienceRole(Integer levelNumber) {
when(role.getId()).thenReturn(ROLE_ID);
when(server.getId()).thenReturn(SERVER_ID);
when(role.getServer()).thenReturn(server);
when(experienceRole.getRole()).thenReturn(role);
when(level.getLevel()).thenReturn(levelNumber);
when(experienceRole.getLevel()).thenReturn(level);
}
}

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

@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.service.management;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
@@ -35,13 +34,19 @@ public class UserExperienceManagementServiceBeanTest {
@Mock
private ExperienceLevelManagementService experienceLevelManagementService;
private static final Long SERVER_ID = 2L;
private static final Long USER_IN_SERVER_ID = 3L;
private static final Long USER_ID = 4L;
private static final Integer START_LEVEL = 0;
@Test
public void testFindUserInServer() {
AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
AUserExperience experience = AUserExperience.builder().user(user).experience(2L).build();
when(repository.findById(user.getUserInServerId())).thenReturn(Optional.of(experience));
AUserExperience userInServer = testUnit.findUserInServer(user);
Assert.assertEquals(experience.getExperience(), userInServer.getExperience());
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(user.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(repository.findById(USER_IN_SERVER_ID)).thenReturn(Optional.of(experience));
AUserExperience retrievedExperience = testUnit.findUserInServer(user);
Assert.assertEquals(experience, retrievedExperience);
}
@Test
@@ -49,17 +54,20 @@ public class UserExperienceManagementServiceBeanTest {
AUserInAServer user = Mockito.mock(AUserInAServer.class);
AServer server = Mockito.mock(AServer.class);
when(user.getServerReference()).thenReturn(server);
when(server.getId()).thenReturn(2L);
when(server.getId()).thenReturn(SERVER_ID);
AUser aUser = Mockito.mock(AUser.class);
when(aUser.getId()).thenReturn(4L);
when(user.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
when(aUser.getId()).thenReturn(USER_ID);
when(user.getUserReference()).thenReturn(aUser);
when(repository.findById(user.getUserInServerId())).thenReturn(Optional.empty());
AExperienceLevel startLevel = mockInitialLevel();
when(repository.findById(USER_IN_SERVER_ID)).thenReturn(Optional.empty());
AExperienceLevel startLevel = Mockito.mock(AExperienceLevel.class);
when(startLevel.getLevel()).thenReturn(START_LEVEL);
when(experienceLevelManagementService.getLevel(START_LEVEL)).thenReturn(Optional.of(startLevel));
AUserExperience userInServer = testUnit.findUserInServer(user);
Assert.assertEquals(0L, userInServer.getExperience().longValue());
Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
Assert.assertFalse(userInServer.getExperienceGainDisabled());
Assert.assertEquals(startLevel.getLevel(), userInServer.getCurrentLevel().getLevel());
Assert.assertEquals(START_LEVEL, userInServer.getCurrentLevel().getLevel());
}
@Test
@@ -67,76 +75,70 @@ public class UserExperienceManagementServiceBeanTest {
AUserInAServer user = Mockito.mock(AUserInAServer.class);
AServer server = Mockito.mock(AServer.class);
when(user.getServerReference()).thenReturn(server);
when(server.getId()).thenReturn(2L);
when(server.getId()).thenReturn(SERVER_ID);
AUser aUser = Mockito.mock(AUser.class);
when(aUser.getId()).thenReturn(4L);
when(aUser.getId()).thenReturn(USER_ID);
when(user.getUserReference()).thenReturn(aUser);
AExperienceLevel startLevel = mockInitialLevel();
AExperienceLevel startLevel = Mockito.mock(AExperienceLevel.class);
when(startLevel.getLevel()).thenReturn(START_LEVEL);
when(experienceLevelManagementService.getLevel(START_LEVEL)).thenReturn(Optional.of(startLevel));
AUserExperience userInServer = testUnit.createUserInServer(user);
Assert.assertEquals(0L, userInServer.getExperience().longValue());
Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
Assert.assertFalse(userInServer.getExperienceGainDisabled());
Assert.assertEquals(startLevel.getLevel(), userInServer.getCurrentLevel().getLevel());
Assert.assertEquals(START_LEVEL, userInServer.getCurrentLevel().getLevel());
}
@Test
public void testLoadAllUsers() {
AServer server = MockUtils.getServer();
List<AUserExperience> experiences = getUserExperiences();
AServer server = Mockito.mock(AServer.class);
AUserExperience experience = Mockito.mock(AUserExperience.class);
AUserExperience experience2 = Mockito.mock(AUserExperience.class);
List<AUserExperience> experiences = Arrays.asList(experience, experience2);
when(repository.findByUser_ServerReference(server)).thenReturn(experiences);
List<AUserExperience> loadedExperiences = testUnit.loadAllUsers(server);
Assert.assertEquals(experiences.size(), loadedExperiences.size());
Assert.assertEquals(experiences.get(0).getExperience(), loadedExperiences.get(0).getExperience());
Assert.assertEquals(experiences.get(1).getExperience(), loadedExperiences.get(1).getExperience());
Assert.assertEquals(experience, loadedExperiences.get(0));
Assert.assertEquals(experience2, loadedExperiences.get(1));
}
@Test
public void testLoadPaginated() {
AServer server = MockUtils.getServer();
AServer server = Mockito.mock(AServer.class);
int endIndex = 20;
int startIndex = 11;
List<AUserExperience> userExperiences = getUserExperiences();
when(repository.findTop10ByUser_ServerReferenceOrderByExperienceDesc(server, PageRequest.of(startIndex, endIndex))).thenReturn(userExperiences);
AUserExperience experience = Mockito.mock(AUserExperience.class);
AUserExperience experience2 = Mockito.mock(AUserExperience.class);
List<AUserExperience> experiences = Arrays.asList(experience, experience2);
when(repository.findTop10ByUser_ServerReferenceOrderByExperienceDesc(server, PageRequest.of(startIndex, endIndex))).thenReturn(experiences);
List<AUserExperience> leaderBoardUsersPaginated = testUnit.findLeaderBoardUsersPaginated(server, startIndex, endIndex);
Assert.assertEquals(userExperiences.size(), leaderBoardUsersPaginated.size());
for (int i = 0; i < userExperiences.size(); i++) {
Assert.assertEquals(userExperiences.get(i).getExperience(), leaderBoardUsersPaginated.get(i).getExperience());
}
Assert.assertEquals(experiences.size(), leaderBoardUsersPaginated.size());
Assert.assertEquals(experience, leaderBoardUsersPaginated.get(0));
Assert.assertEquals(experience2, leaderBoardUsersPaginated.get(1));
}
@Test
public void testLoadRankOfUser() {
long experienceValue = 2L;
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(6L, server);
AUserExperience experience = AUserExperience.builder().experience(experienceValue).user(user).id(3L).build();
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(experience.getServer()).thenReturn(server);
when(experience.getId()).thenReturn(USER_IN_SERVER_ID);
LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
when(leaderBoardEntryTest.getExperience()).thenReturn(experienceValue);
when(repository.getRankOfUserInServer(experience.getId(), server.getId())).thenReturn(leaderBoardEntryTest);
when(repository.getRankOfUserInServer(USER_IN_SERVER_ID, SERVER_ID)).thenReturn(leaderBoardEntryTest);
LeaderBoardEntryResult rankOfUserInServer = testUnit.getRankOfUserInServer(experience);
Assert.assertEquals(experienceValue, rankOfUserInServer.getExperience().longValue());
}
@Test
public void testSaveUser() {
AUserInAServer user = AUserInAServer.builder().userInServerId(1L).userReference(AUser.builder().id(2L).build()).build();
AUserExperience experience = AUserExperience.builder().user(user).experience(2L).build();
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(repository.save(experience)).thenReturn(experience);
AUserExperience createdInstance = testUnit.saveUser(experience);
Assert.assertEquals(experience.getExperience(), createdInstance.getExperience());
Assert.assertEquals(experience.getUser().getUserReference().getId(), createdInstance.getUser().getUserReference().getId());
Assert.assertEquals(experience, createdInstance);
}
private AExperienceLevel mockInitialLevel() {
AExperienceLevel startLevel = AExperienceLevel.builder().level(0).experienceNeeded(0L).build();
when(experienceLevelManagementService.getLevel(startLevel.getLevel())).thenReturn(Optional.of(startLevel));
return startLevel;
}
private List<AUserExperience> getUserExperiences() {
AUserExperience experience = AUserExperience.builder().experience(2L).build();
AUserExperience experience2 = AUserExperience.builder().experience(2L).build();
return Arrays.asList(experience, experience2);
}
}

2
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/models/database/AExperienceRole.java
View File

@@ -49,7 +49,7 @@ public class AExperienceRole implements Serializable {
@Getter
@Setter
@JoinColumn(name = "server_id", nullable = false)
private AServer roleServer;
private AServer server;
@Column(name = "created")
private Instant created;

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/converter/UserNotesConverter.java
View File

@@ -56,7 +56,7 @@ public class UserNotesConverter {
List<NoteEntryModel> entryModels = new ArrayList<>();
futureHashMap.keySet().forEach(serverSpecificId -> {
Member member = futureHashMap.get(serverSpecificId).join();
UserNote note = userNoteManagementService.loadNote(serverSpecificId.getId(), serverSpecificId.getServerId());
UserNote note = userNoteManagementService.loadNote(serverSpecificId.getServerId(), serverSpecificId.getId());
FullUserInServer fullUser = FullUserInServer
.builder()
.member(member)

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBean.java
View File

@@ -47,7 +47,7 @@ public class UserNoteManagementServiceBean implements UserNoteManagementService
}
@Override
public UserNote loadNote(Long userNoteId, Long serverId) {
public UserNote loadNote(Long serverId, Long userNoteId) {
return userNoteRepository.findByUserNoteId_IdAndUserNoteId_ServerId(userNoteId, serverId);
}

13
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/DeleteWarningTest.java
View File

@@ -2,9 +2,6 @@ package dev.sheldan.abstracto.moderation.commands;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.moderation.models.database.Warning;
@@ -13,6 +10,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -29,15 +27,14 @@ public class DeleteWarningTest {
private WarnManagementService warnManagementService;
private static final Long WARN_ID = 5L;
private static final Long SERVER_ID = 1L;
@Test
public void testDeleteExistingWarning() {
AServer server = MockUtils.getServer();
AUserInAServer warnedUser = MockUtils.getUserObject(5L, server);
AUserInAServer warningUser = MockUtils.getUserObject(6L, server);
Warning existingWarning = Warning.builder().warnedUser(warnedUser).warningUser(warningUser).build();
Warning existingWarning = Mockito.mock(Warning.class);
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(WARN_ID));
when(warnManagementService.findByIdOptional(WARN_ID, parameters.getGuild().getIdLong())).thenReturn(Optional.of(existingWarning));
when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
when(warnManagementService.findByIdOptional(WARN_ID, SERVER_ID)).thenReturn(Optional.of(existingWarning));
CommandResult result = testUnit.execute(parameters);
verify(warnManagementService, times(1)).deleteWarning(existingWarning);
CommandTestUtilities.checkSuccessfulCompletion(result);

5
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/UserNoteCommandTest.java
View File

@@ -2,10 +2,8 @@ package dev.sheldan.abstracto.moderation.commands;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
@@ -36,8 +34,7 @@ public class UserNoteCommandTest {
@Test
public void testExecuteUserNoteCommand() {
Member member = Mockito.mock(Member.class);
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(4L, server);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
String note = "note";
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(member, note));
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(userInAServer);

20
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/UserNotesTest.java
View File

@@ -7,7 +7,6 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.moderation.converter.UserNotesConverter;
@@ -56,15 +55,14 @@ public class UserNotesTest {
public void testExecuteUserNotesCommandForMember() {
Member member = Mockito.mock(Member.class);
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(member));
AServer server = Mockito.mock(AServer.class);
AUserInAServer userNoteUser = MockUtils.getUserObject(4L, server);
AUserInAServer userNoteUser = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(userNoteUser);
UserNote firstNote = UserNote.builder().build();
UserNote secondNote = UserNote.builder().build();
UserNote firstNote = Mockito.mock(UserNote.class);
UserNote secondNote = Mockito.mock(UserNote.class);
List<UserNote> userNotes = Arrays.asList(firstNote, secondNote);
when(userNoteManagementService.loadNotesForUser(userNoteUser)).thenReturn(userNotes);
NoteEntryModel firstConvertedNote = NoteEntryModel.builder().build();
NoteEntryModel secondConvertedNote = NoteEntryModel.builder().build();
NoteEntryModel firstConvertedNote = Mockito.mock(NoteEntryModel.class);
NoteEntryModel secondConvertedNote = Mockito.mock(NoteEntryModel.class);
CompletableFuture<List<NoteEntryModel>> convertedNotes = CompletableFuture.completedFuture(Arrays.asList(firstConvertedNote, secondConvertedNote));
when(userNotesConverter.fromNotes(userNotes)).thenReturn(convertedNotes);
CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
@@ -85,14 +83,14 @@ public class UserNotesTest {
@Test
public void testExecuteUserNotesCommandForServer() {
CommandContext parameters = CommandTestUtilities.getNoParameters();
UserNote firstNote = UserNote.builder().build();
UserNote secondNote = UserNote.builder().build();
UserNote firstNote = Mockito.mock(UserNote.class);
UserNote secondNote = Mockito.mock(UserNote.class);
List<UserNote> userNotes = Arrays.asList(firstNote, secondNote);
AServer server = Mockito.mock(AServer.class);
when(serverManagementService.loadServer(parameters.getGuild())).thenReturn(server);
when(userNoteManagementService.loadNotesForServer(server)).thenReturn(userNotes);
NoteEntryModel firstConvertedNote = NoteEntryModel.builder().build();
NoteEntryModel secondConvertedNote = NoteEntryModel.builder().build();
NoteEntryModel firstConvertedNote = Mockito.mock(NoteEntryModel.class);
NoteEntryModel secondConvertedNote = Mockito.mock(NoteEntryModel.class);
CompletableFuture<List<NoteEntryModel>> convertedNotes = CompletableFuture.completedFuture(Arrays.asList(firstConvertedNote, secondConvertedNote));
when(userNotesConverter.fromNotes(userNotes)).thenReturn(convertedNotes);
CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);

5
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/mute/UnMuteTest.java
View File

@@ -14,6 +14,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -42,7 +43,7 @@ public class UnMuteTest {
@Test
public void testUnMuteCommand() {
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(memberToUnMute));
AUserInAServer user = AUserInAServer.builder().build();
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadOrCreateUser(memberToUnMute)).thenReturn(user);
when(muteService.unMuteUser(user)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
@@ -52,7 +53,7 @@ public class UnMuteTest {
@Test(expected = NoMuteFoundException.class)
public void testUnMuteCommandWithoutExistingMute() {
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(memberToUnMute));
AUserInAServer user = AUserInAServer.builder().build();
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadOrCreateUser(memberToUnMute)).thenReturn(user);
when(muteService.unMuteUser(user)).thenThrow(new NoMuteFoundException());
testUnit.executeAsync(parameters);

22
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/converter/UserNotesConverterTest.java
View File

@@ -1,11 +1,9 @@
package dev.sheldan.abstracto.moderation.converter;
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.MemberService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.moderation.models.database.UserNote;
import dev.sheldan.abstracto.moderation.models.template.commands.NoteEntryModel;
import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
@@ -44,6 +42,9 @@ public class UserNotesConverterTest {
@Mock
private UserNoteManagementService userNoteManagementService;
private static final Long SERVER_ID = 3L;
private static final Long USER_NOTE_ID = 4L;
@Test
public void testWithEmptyList() {
CompletableFuture<List<NoteEntryModel>> entryModels = testUnit.fromNotes(Collections.emptyList());
@@ -52,12 +53,13 @@ public class UserNotesConverterTest {
@Test
public void testWithSomeUserNotes() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(4L, server);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
Member member = Mockito.mock(Member.class);
when(memberService.getMemberInServerAsync(userInAServer)).thenReturn(CompletableFuture.completedFuture(member));
UserNote firstNote = UserNote.builder().userNoteId(new ServerSpecificId(3L, 4L)).user(userInAServer).build();
UserNote secondNote = UserNote.builder().userNoteId(new ServerSpecificId(3L, 5L)).user(userInAServer).build();
UserNote firstNote = Mockito.mock(UserNote.class);
when(firstNote.getUser()).thenReturn(userInAServer);
UserNote secondNote = Mockito.mock(UserNote.class);
when(secondNote.getUser()).thenReturn(userInAServer);
testUnit.fromNotes(Arrays.asList(firstNote, secondNote));
verify(self, times(1)).loadFullNotes(any());
}
@@ -70,13 +72,13 @@ public class UserNotesConverterTest {
UserNote note2 = Mockito.mock(UserNote.class);
when(note1.getUser()).thenReturn(userInAServer);
when(note2.getUser()).thenReturn(userInAServer);
ServerSpecificId firstUserNoteId = new ServerSpecificId(3L, 4L);
ServerSpecificId secondUserNoteId = new ServerSpecificId(3L, 5L);
ServerSpecificId firstUserNoteId = new ServerSpecificId(SERVER_ID, USER_NOTE_ID);
ServerSpecificId secondUserNoteId = new ServerSpecificId(SERVER_ID, USER_NOTE_ID + 1);
HashMap<ServerSpecificId, CompletableFuture<Member>> map = new HashMap<>();
map.put(firstUserNoteId, CompletableFuture.completedFuture(member));
map.put(secondUserNoteId, CompletableFuture.completedFuture(member));
when(userNoteManagementService.loadNote(4L, 3L)).thenReturn(note1);
when(userNoteManagementService.loadNote(5L, 3L)).thenReturn(note2);
when(userNoteManagementService.loadNote(SERVER_ID, USER_NOTE_ID)).thenReturn(note1);
when(userNoteManagementService.loadNote(SERVER_ID, USER_NOTE_ID + 1)).thenReturn(note2);
List<NoteEntryModel> models = testUnit.loadFullNotes(map);
Assert.assertEquals(2, models.size());
NoteEntryModel firstEntry = models.get(0);

28
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/converter/WarnEntryConverterTest.java
View File

@@ -18,10 +18,7 @@ import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@@ -56,21 +53,30 @@ public class WarnEntryConverterTest {
}
@Test
public void testWithSomeUserNotes() {
public void testWithSomeWarnings() {
AUserInAServer warnedUser = Mockito.mock(AUserInAServer.class);
AUserInAServer warningUser = Mockito.mock(AUserInAServer.class);
Member warnedMember = Mockito.mock(Member.class);
Member warningMember = Mockito.mock(Member.class);
when(memberService.getMemberInServerAsync(warnedUser)).thenReturn(CompletableFuture.completedFuture(warnedMember));
when(memberService.getMemberInServerAsync(warningUser)).thenReturn(CompletableFuture.completedFuture(warningMember));
Warning firstNote = Warning.builder().warnId(new ServerSpecificId(3L, 4L)).warnedUser(warnedUser).warningUser(warningUser).build();
Warning secondNote = Warning.builder().warnId(new ServerSpecificId(3L, 5L)).warnedUser(warnedUser).warningUser(warningUser).build();
testUnit.fromWarnings(Arrays.asList(firstNote, secondNote));
Warning firstWarning = Mockito.mock(Warning.class);
when(firstWarning.getWarningUser()).thenReturn(warningUser);
when(firstWarning.getWarnedUser()).thenReturn(warnedUser);
Warning secondWarning = Mockito.mock(Warning.class);
when(secondWarning.getWarningUser()).thenReturn(warningUser);
when(secondWarning.getWarnedUser()).thenReturn(warnedUser);
List<WarnEntry> loaded = new ArrayList<>();
when(self.loadFullWarnEntries(any())).thenReturn(loaded);
CompletableFuture<List<WarnEntry>> future = testUnit.fromWarnings(Arrays.asList(firstWarning, secondWarning));
List<WarnEntry> entries = future.join();
Assert.assertFalse(future.isCompletedExceptionally());
Assert.assertEquals(loaded, entries);
verify(self, times(1)).loadFullWarnEntries(any());
}
@Test
public void testLoadingFullNotes() {
public void testLoadingFullWarnings() {
AUserInAServer warnedUser = Mockito.mock(AUserInAServer.class);
AUserInAServer warningUser = Mockito.mock(AUserInAServer.class);
Member warningMember = Mockito.mock(Member.class);
@@ -82,7 +88,9 @@ public class WarnEntryConverterTest {
ServerSpecificId secondWarnId = new ServerSpecificId(SERVER_ID, WARN_ID_2);
when(warning2.getWarnId()).thenReturn(secondWarnId);
HashMap<ServerSpecificId, FutureMemberPair> map = new HashMap<>();
FutureMemberPair memberPair = FutureMemberPair.builder().firstMember(CompletableFuture.completedFuture(warningMember)).secondMember(CompletableFuture.completedFuture(warnedMember)).build();
FutureMemberPair memberPair = Mockito.mock(FutureMemberPair.class);
when(memberPair.getFirstMember()).thenReturn(CompletableFuture.completedFuture(warningMember));
when(memberPair.getSecondMember()).thenReturn(CompletableFuture.completedFuture(warnedMember));
map.put(firstWarnId, memberPair);
map.put(secondWarnId, memberPair);
when(warnManagementService.findById(WARN_ID_1, SERVER_ID)).thenReturn(warning1);

16
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/job/WarnDecayJobTest.java
View File

@@ -3,11 +3,9 @@ package dev.sheldan.abstracto.moderation.job;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.FeatureFlagService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
import dev.sheldan.abstracto.moderation.service.WarnService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
@@ -41,14 +39,14 @@ public class WarnDecayJobTest {
@Mock
private WarnService warnService;
@Mock
private AServer firstServer;
@Mock
private AServer secondServer;
@Before
public void setup() {
this.firstServer = MockUtils.getServer(1L);
this.secondServer = MockUtils.getServer(2L);
}
private static final Long SERVER_ID = 1L;
private static final Long SERVER_ID_2 = 2L;
@Test
public void executeJobForNoServers() throws JobExecutionException {
@@ -60,6 +58,7 @@ public class WarnDecayJobTest {
@Test
public void executeJobForAEnabledServer() throws JobExecutionException {
when(firstServer.getId()).thenReturn(SERVER_ID);
when(serverManagementService.getAllServers()).thenReturn(Arrays.asList(firstServer));
when(featureFlagService.isFeatureEnabled(warningDecayFeature, firstServer)).thenReturn(true);
testUnit.executeInternal(null);
@@ -76,6 +75,7 @@ public class WarnDecayJobTest {
@Test
public void executeJobForMixedServers() throws JobExecutionException {
when(firstServer.getId()).thenReturn(SERVER_ID);
when(serverManagementService.getAllServers()).thenReturn(Arrays.asList(firstServer, secondServer));
when(featureFlagService.isFeatureEnabled(warningDecayFeature, firstServer)).thenReturn(true);
when(featureFlagService.isFeatureEnabled(warningDecayFeature, secondServer)).thenReturn(false);
@@ -85,6 +85,8 @@ public class WarnDecayJobTest {
@Test
public void executeJobForMultipleEnabledServers() throws JobExecutionException {
when(firstServer.getId()).thenReturn(SERVER_ID);
when(secondServer.getId()).thenReturn(SERVER_ID_2);
when(serverManagementService.getAllServers()).thenReturn(Arrays.asList(firstServer, secondServer));
when(featureFlagService.isFeatureEnabled(warningDecayFeature, firstServer)).thenReturn(true);
when(featureFlagService.isFeatureEnabled(warningDecayFeature, secondServer)).thenReturn(true);

13
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/PurgeServiceBeanTest.java
View File

@@ -25,8 +25,8 @@ import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import static dev.sheldan.abstracto.core.test.MockUtils.mockQueueDoubleVoidConsumer;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
@@ -252,6 +252,17 @@ public class PurgeServiceBeanTest {
setupStatusMessageMocks();
}
public void mockQueueDoubleVoidConsumer(RestAction action) {
doAnswer(invocationOnMock -> {
Object consumerObj = invocationOnMock.getArguments()[0];
if(consumerObj instanceof Consumer) {
Consumer<Void> consumer = (Consumer) consumerObj;
consumer.accept(null);
}
return null;
}).when(action).queue(any(Consumer.class), any(Consumer.class));
}
private void setupFirstMessageHistoryMocks() {
List<Message> messagesToDelete = Arrays.asList(firstMessage, secondMessage);
when(history.getRetrievedHistory()).thenReturn(messagesToDelete);

23
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/SlowModeServiceBeanTest.java
View File

@@ -4,7 +4,6 @@ import dev.sheldan.abstracto.core.exception.ChannelNotInGuildException;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.test.MockUtils;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.TextChannel;
import net.dv8tion.jda.api.managers.ChannelManager;
@@ -12,6 +11,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Duration;
@@ -37,6 +37,9 @@ public class SlowModeServiceBeanTest {
@Mock
private TextChannel channel;
private static final Long SERVER_ID = 4L;
private static final Long CHANNEL_ID = 5L;
@Test
public void setSlowModeInTextChannel() {
when(channel.getGuild()).thenReturn(guild);
@@ -47,11 +50,14 @@ public class SlowModeServiceBeanTest {
@Test
public void testSlowModeInAChannel() {
AServer server = MockUtils.getServer();
AChannel aChannel = MockUtils.getTextChannel(server, 5L);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
AChannel aChannel = Mockito.mock(AChannel.class);
when(aChannel.getServer()).thenReturn(server);
when(aChannel.getId()).thenReturn(CHANNEL_ID);
Duration duration = Duration.ofMinutes(5);
when(channel.getGuild()).thenReturn(guild);
when(channelService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.of(channel));
when(channelService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.of(channel));
testUnit.setSlowMode(aChannel, duration);
verify(channelService, times(1)).setSlowModeInChannel(channel,(int) duration.getSeconds());
}
@@ -72,10 +78,13 @@ public class SlowModeServiceBeanTest {
@Test(expected = ChannelNotInGuildException.class)
public void testSlowModeInAChannelNotFound() {
AServer server = MockUtils.getServer();
AChannel aChannel = MockUtils.getTextChannel(server, 5L);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
AChannel aChannel = Mockito.mock(AChannel.class);
when(aChannel.getServer()).thenReturn(server);
when(aChannel.getId()).thenReturn(CHANNEL_ID);
Duration duration = Duration.ofMinutes(5);
when(channelService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.empty());
when(channelService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.empty());
testUnit.setSlowMode(aChannel, duration);
}
}

68
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/MuteManagementServiceBeanTest.java
View File

@@ -4,9 +4,9 @@ import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.models.database.AChannel;
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.core.test.MockUtils;
import dev.sheldan.abstracto.moderation.models.database.Mute;
import dev.sheldan.abstracto.moderation.repository.MuteRepository;
import net.dv8tion.jda.api.entities.Member;
@@ -38,17 +38,28 @@ public class MuteManagementServiceBeanTest {
@Captor
private ArgumentCaptor<Mute> muteArgumentCaptor;
private static final Long SERVER_ID = 1L;
private static final Long MUTE_ID = 2L;
@Test
public void testCreateMute() {
AServer server = MockUtils.getServer();
AServer server = Mockito.mock(AServer.class);
long messageId = 9L;
AChannel channel = MockUtils.getTextChannel(server, 8L);
AUserInAServer mutingUser = MockUtils.getUserObject(5L, server);
AUserInAServer mutedUser = MockUtils.getUserObject(7L, server);
AChannel channel = Mockito.mock(AChannel.class);
AUserInAServer mutingUser = Mockito.mock(AUserInAServer.class);
AUserInAServer mutedUser = Mockito.mock(AUserInAServer.class);
AUser user = Mockito.mock(AUser.class);
when(mutedUser.getUserReference()).thenReturn(user);
when(mutedUser.getServerReference()).thenReturn(server);
AUser secondUser = Mockito.mock(AUser.class);
when(mutingUser.getUserReference()).thenReturn(secondUser);
String reason = "reason";
String triggerKey = "key";
Instant unMuteDate = Instant.now();
AServerAChannelMessage muteMessage = AServerAChannelMessage.builder().server(server).channel(channel).messageId(messageId).build();
AServerAChannelMessage muteMessage = Mockito.mock(AServerAChannelMessage.class);
when(muteMessage.getMessageId()).thenReturn(messageId);
when(muteMessage.getServer()).thenReturn(server);
when(muteMessage.getChannel()).thenReturn(channel);
testUnit.createMute(mutedUser, mutingUser, reason, unMuteDate, muteMessage, triggerKey, 8L);
verify(muteRepository, times(1)).save(muteArgumentCaptor.capture());
@@ -65,36 +76,34 @@ public class MuteManagementServiceBeanTest {
@Test
public void testFindMute() {
Long id = 5L;
Long serverId = 7L;
Mute mute = Mute.builder().muteId(new ServerSpecificId(serverId, id)).build();
when(muteRepository.findByMuteId_IdAndMuteId_ServerId(id, serverId)).thenReturn(Optional.of(mute));
Optional<Mute> foundMuteOptional = testUnit.findMuteOptional(id, serverId);
Mute mute = Mockito.mock(Mute.class);
ServerSpecificId muteId = Mockito.mock(ServerSpecificId.class);
when(mute.getMuteId()).thenReturn(muteId);
when(muteId.getId()).thenReturn(MUTE_ID);
when(muteRepository.findByMuteId_IdAndMuteId_ServerId(MUTE_ID, SERVER_ID)).thenReturn(Optional.of(mute));
Optional<Mute> foundMuteOptional = testUnit.findMuteOptional(MUTE_ID, SERVER_ID);
Assert.assertTrue(foundMuteOptional.isPresent());
foundMuteOptional.ifPresent(foundMute -> Assert.assertEquals(id, foundMute.getMuteId().getId()));
foundMuteOptional.ifPresent(foundMute -> Assert.assertEquals(MUTE_ID, foundMute.getMuteId().getId()));
}
@Test
public void testFindNonExistingMute() {
Long id = 5L;
Long serverId = 7L;
when(muteRepository.findByMuteId_IdAndMuteId_ServerId(id, serverId)).thenReturn(Optional.empty());
Optional<Mute> foundMuteOptional = testUnit.findMuteOptional(id, serverId);
when(muteRepository.findByMuteId_IdAndMuteId_ServerId(MUTE_ID, SERVER_ID)).thenReturn(Optional.empty());
Optional<Mute> foundMuteOptional = testUnit.findMuteOptional(MUTE_ID, SERVER_ID);
Assert.assertFalse(foundMuteOptional.isPresent());
}
@Test
public void testSaveMute() {
Mute mute = Mute.builder().build();
Mute mute = Mockito.mock(Mute.class);
testUnit.saveMute(mute);
verify(muteRepository, times(1)).save(mute);
}
@Test
public void testGetMuteOfUser() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(9L, server);
Mute mute = Mute.builder().build();
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
Mute mute = Mockito.mock(Mute.class);
when(muteRepository.findTopByMutedUserAndMuteEndedFalse(userInAServer)).thenReturn(mute);
Mute aMuteOf = testUnit.getAMuteOf(userInAServer);
Assert.assertEquals(mute, aMuteOf);
@@ -102,11 +111,10 @@ public class MuteManagementServiceBeanTest {
@Test
public void testGetMuteOfMember() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(9L, server);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
Mute mute = Mockito.mock(Mute.class);
Member member = Mockito.mock(Member.class);
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(userInAServer);
Mute mute = Mute.builder().build();
when(muteRepository.findTopByMutedUserAndMuteEndedFalse(userInAServer)).thenReturn(mute);
Mute aMuteOf = testUnit.getAMuteOf(member);
Assert.assertEquals(mute, aMuteOf);
@@ -114,14 +122,13 @@ public class MuteManagementServiceBeanTest {
@Test
public void testGetAllMutesOf() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(9L, server);
Mute mute1 = Mute.builder().build();
Mute mute2 = Mute.builder().build();
when(muteRepository.findAllByMutedUserAndMuteEndedFalseOrderByMuteId_IdDesc(userInAServer)).thenReturn(Arrays.asList(mute1, mute2));
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
Mute mute = Mockito.mock(Mute.class);
Mute mute2 = Mockito.mock(Mute.class);
when(muteRepository.findAllByMutedUserAndMuteEndedFalseOrderByMuteId_IdDesc(userInAServer)).thenReturn(Arrays.asList(mute, mute2));
List<Mute> allMutesOf = testUnit.getAllMutesOf(userInAServer);
Assert.assertEquals(2, allMutesOf.size());
Assert.assertEquals(mute1, allMutesOf.get(0));
Assert.assertEquals(mute, allMutesOf.get(0));
Assert.assertEquals(mute2, allMutesOf.get(1));
}
@@ -136,8 +143,7 @@ public class MuteManagementServiceBeanTest {
}
private void checkExist(boolean value) {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(9L, server);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(muteRepository.existsByMutedUserAndMuteEndedFalse(userInAServer)).thenReturn(value);
boolean result = testUnit.hasActiveMute(userInAServer);
Assert.assertEquals(value, result);

27
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/MuteRoleManagementServiceBeanTest.java
View File

@@ -2,15 +2,14 @@ package dev.sheldan.abstracto.moderation.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.moderation.models.database.MuteRole;
import dev.sheldan.abstracto.moderation.repository.MuteRoleRepository;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -27,16 +26,12 @@ public class MuteRoleManagementServiceBeanTest {
@Mock
private MuteRoleRepository muteRoleRepository;
@Mock
private AServer server;
@Before
public void setup() {
this.server = MockUtils.getServer();
}
@Test
public void testRetrieveMuteRoleForServer() {
MuteRole role = getMuteRole();
MuteRole role = Mockito.mock(MuteRole.class);
when(muteRoleRepository.findByRoleServer(server)).thenReturn(role);
MuteRole muteRole = testUnit.retrieveMuteRoleForServer(server);
Assert.assertEquals(role, muteRole);
@@ -50,14 +45,14 @@ public class MuteRoleManagementServiceBeanTest {
@Test
public void testCreateMuteRoleForServer() {
ARole role = ARole.builder().build();
ARole role = Mockito.mock(ARole.class);
MuteRole muteRoleForServer = testUnit.createMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRoleForServer, 1);
}
@Test
public void testRetrieveRolesForServer() {
List<MuteRole> existingRoles = Arrays.asList(getMuteRole(), getMuteRole());
List<MuteRole> existingRoles = Arrays.asList(Mockito.mock(MuteRole.class), Mockito.mock(MuteRole.class));
when(muteRoleRepository.findAllByRoleServer(server)).thenReturn(existingRoles);
List<MuteRole> foundRoles = testUnit.retrieveMuteRolesForServer(server);
Assert.assertEquals(existingRoles.size(), foundRoles.size());
@@ -70,7 +65,7 @@ public class MuteRoleManagementServiceBeanTest {
@Test
public void testSetMuteRoleWithoutPrevious() {
ARole role = ARole.builder().build();
ARole role = Mockito.mock(ARole.class);
when(muteRoleRepository.existsByRoleServer(server)).thenReturn(false);
MuteRole muteRole = testUnit.setMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRole, 1);
@@ -78,9 +73,10 @@ public class MuteRoleManagementServiceBeanTest {
@Test
public void testSetMuteRoleWithPrevious() {
ARole role = ARole.builder().build();
ARole role = Mockito.mock(ARole.class);
when(muteRoleRepository.existsByRoleServer(server)).thenReturn(true);
MuteRole existingRole = getMuteRole();
MuteRole existingRole = Mockito.mock(MuteRole.class);
when(existingRole.getRole()).thenReturn(role);
when(muteRoleRepository.findByRoleServer(server)).thenReturn(existingRole);
MuteRole muteRole = testUnit.setMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRole, 0);
@@ -88,13 +84,8 @@ public class MuteRoleManagementServiceBeanTest {
private void verifyRoleSaved(ARole role, MuteRole muteRoleForServer, Integer saveCount) {
Assert.assertEquals(role, muteRoleForServer.getRole());
Assert.assertEquals(server, muteRoleForServer.getRoleServer());
verify(muteRoleRepository, times(saveCount)).save(muteRoleForServer);
}
private MuteRole getMuteRole() {
return MuteRole.builder().roleServer(server).build();
}
}

35
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBeanTest.java
View File

@@ -1,17 +1,17 @@
package dev.sheldan.abstracto.moderation.service.management;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.CounterService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.moderation.models.database.UserNote;
import dev.sheldan.abstracto.moderation.repository.UserNoteRepository;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -33,40 +33,43 @@ public class UserNoteManagementServiceBeanTest {
private static final String NOTE_TEXT = "noteText";
private static final Long NOTE_ID = 5L;
private static final Long SERVER_ID = 1L;
@Mock
private AServer server;
private AUserInAServer userInAServer;
@Before
public void setup() {
this.server = MockUtils.getServer();
this.userInAServer = MockUtils.getUserObject(8L, server);
}
@Mock
private AUserInAServer userInAServer;
@Test
public void testCreateUserNote() {
AUser user = Mockito.mock(AUser.class);
when(userInAServer.getUserReference()).thenReturn(user);
when(userInAServer.getServerReference()).thenReturn(server);
UserNote userNote = testUnit.createUserNote(userInAServer, NOTE_TEXT);
verify(userNoteRepository, times(1)).save(userNote);
Assert.assertEquals(userNote.getUser(), userInAServer);
Assert.assertEquals(userNote.getNote(), NOTE_TEXT);
Assert.assertEquals(userInAServer, userNote.getUser());
Assert.assertEquals(NOTE_TEXT, userNote.getNote());
}
@Test
public void testDeleteNote() {
when(server.getId()).thenReturn(SERVER_ID);
testUnit.deleteNote(NOTE_ID, server);
verify(userNoteRepository, times(1)).deleteByUserNoteId_IdAndUserNoteId_ServerId(NOTE_ID, server.getId());
verify(userNoteRepository, times(1)).deleteByUserNoteId_IdAndUserNoteId_ServerId(NOTE_ID, SERVER_ID);
}
@Test
public void testNoteExists() {
when(userNoteRepository.existsByUserNoteId_IdAndUserNoteId_ServerId(NOTE_ID, server.getId())).thenReturn(true);
when(server.getId()).thenReturn(SERVER_ID);
when(userNoteRepository.existsByUserNoteId_IdAndUserNoteId_ServerId(NOTE_ID, SERVER_ID)).thenReturn(true);
Assert.assertTrue(testUnit.noteExists(NOTE_ID, server));
}
@Test
public void testLoadNotesForUser() {
UserNote note = UserNote.builder().build();
UserNote note2 = UserNote.builder().build();
UserNote note = Mockito.mock(UserNote.class);
UserNote note2 = Mockito.mock(UserNote.class);
List<UserNote> notes = Arrays.asList(note, note2);
when(userNoteRepository.findByUser(userInAServer)).thenReturn(notes);
List<UserNote> foundNotes = testUnit.loadNotesForUser(userInAServer);
@@ -80,8 +83,8 @@ public class UserNoteManagementServiceBeanTest {
@Test
public void testLoadNotesForServer() {
UserNote note = UserNote.builder().build();
UserNote note2 = UserNote.builder().build();
UserNote note = Mockito.mock(UserNote.class);
UserNote note2 = Mockito.mock(UserNote.class);
List<UserNote> notes = Arrays.asList(note, note2);
when(userNoteRepository.findByUser_ServerReference(server)).thenReturn(notes);
List<UserNote> foundNotes = testUnit.loadNotesForServer(server);

50
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/WarnManagementServiceBeanTest.java
View File

@@ -2,16 +2,16 @@ package dev.sheldan.abstracto.moderation.service.management;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
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.moderation.models.database.Warning;
import dev.sheldan.abstracto.moderation.repository.WarnRepository;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Instant;
@@ -30,19 +30,22 @@ public class WarnManagementServiceBeanTest {
@Mock
private WarnRepository warnRepository;
@Mock
private AUserInAServer warnedUser;
@Mock
private AServer server;
@Before
public void setup() {
this.server = MockUtils.getServer();
this.warnedUser = MockUtils.getUserObject(5L, server);
}
private static final Long SERVER_ID = 1L;
private static final Long WARN_ID = 2L;
@Test
public void testCreateWarning() {
AUserInAServer warningUser = MockUtils.getUserObject(7L, server);
AUserInAServer warningUser = Mockito.mock(AUserInAServer.class);
AUser user = Mockito.mock(AUser.class);
when(warningUser.getServerReference()).thenReturn(server);
when(warningUser.getUserReference()).thenReturn(user);
when(warnedUser.getUserReference()).thenReturn(user);
String reason = "REASON";
Warning warning = testUnit.createWarning(warnedUser, warningUser, reason, 8L);
Assert.assertEquals(warningUser, warning.getWarningUser());
@@ -55,7 +58,7 @@ public class WarnManagementServiceBeanTest {
@Test
public void testRetrieveWarningsOlderThan() {
Instant date = Instant.now();
List<Warning> existingWarnings = Arrays.asList(getWarning(), getWarning());
List<Warning> existingWarnings = Arrays.asList(Mockito.mock(Warning.class), Mockito.mock(Warning.class));
when(warnRepository.findAllByWarnedUser_ServerReferenceAndDecayedFalseAndWarnDateLessThan(server, date)).thenReturn(existingWarnings);
List<Warning> activeWarningsInServerOlderThan = testUnit.getActiveWarningsInServerOlderThan(server, date);
checkFoundWarns(existingWarnings, activeWarningsInServerOlderThan);
@@ -71,7 +74,7 @@ public class WarnManagementServiceBeanTest {
@Test
public void testGetAllWarningsOfUser() {
List<Warning> existingWarnings = Arrays.asList(getWarning(), getWarning());
List<Warning> existingWarnings = Arrays.asList(Mockito.mock(Warning.class), Mockito.mock(Warning.class));
when(warnRepository.findByWarnedUser(warnedUser)).thenReturn(existingWarnings);
List<Warning> foundWarnings = testUnit.getAllWarnsForUser(warnedUser);
checkFoundWarns(existingWarnings, foundWarnings);
@@ -79,7 +82,7 @@ public class WarnManagementServiceBeanTest {
@Test
public void testGetAllWarningsOfServer() {
List<Warning> existingWarnings = Arrays.asList(getWarning(), getWarning());
List<Warning> existingWarnings = Arrays.asList(Mockito.mock(Warning.class), Mockito.mock(Warning.class));
when(warnRepository.findAllByWarnedUser_ServerReference(server)).thenReturn(existingWarnings);
List<Warning> foundWarnings = testUnit.getAllWarningsOfServer(server);
checkFoundWarns(existingWarnings, foundWarnings);
@@ -95,11 +98,9 @@ public class WarnManagementServiceBeanTest {
@Test
public void testFindByIdExisting() {
Long warnId = 6L;
Long serverId = 8L;
Warning existingWarning = getWarning();
when(warnRepository.findByWarnId_IdAndWarnId_ServerId(warnId, serverId)).thenReturn(Optional.ofNullable(existingWarning));
Optional<Warning> warningOptional = testUnit.findByIdOptional(warnId, serverId);
Warning existingWarning = Mockito.mock(Warning.class);
when(warnRepository.findByWarnId_IdAndWarnId_ServerId(WARN_ID, SERVER_ID)).thenReturn(Optional.ofNullable(existingWarning));
Optional<Warning> warningOptional = testUnit.findByIdOptional(WARN_ID, SERVER_ID);
Assert.assertTrue(warningOptional.isPresent());
warningOptional.ifPresent(foundWarning -> Assert.assertEquals(existingWarning, foundWarning));
}
@@ -107,15 +108,18 @@ public class WarnManagementServiceBeanTest {
@Test
public void testFindByIdNotExisting() {
Long warnId = 6L;
Long serverId = 8L;
when(warnRepository.findByWarnId_IdAndWarnId_ServerId(warnId, serverId)).thenReturn(Optional.ofNullable(null));
Optional<Warning> warningOptional = testUnit.findByIdOptional(warnId, serverId);
when(warnRepository.findByWarnId_IdAndWarnId_ServerId(warnId, SERVER_ID)).thenReturn(Optional.ofNullable(null));
Optional<Warning> warningOptional = testUnit.findByIdOptional(warnId, SERVER_ID);
Assert.assertFalse(warningOptional.isPresent());
}
@Test
public void testDeleteWarning() {
Warning warning = getWarning();
Warning warning = Mockito.mock(Warning.class);
ServerSpecificId warnId = Mockito.mock(ServerSpecificId.class);
when(warnId.getServerId()).thenReturn(SERVER_ID);
when(warnId.getId()).thenReturn(WARN_ID);
when(warning.getWarnId()).thenReturn(warnId);
testUnit.deleteWarning(warning);
verify(warnRepository, times(1)).delete(warning);
}
@@ -130,7 +134,5 @@ public class WarnManagementServiceBeanTest {
}
}
private Warning getWarning() {
return Warning.builder().warnId(new ServerSpecificId(3L, 4L)).build();
}
}

2
abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementService.java
View File

@@ -9,7 +9,7 @@ import java.util.List;
public interface UserNoteManagementService {
UserNote createUserNote(AUserInAServer aUserInAServer, String note);
void deleteNote(Long id, AServer server);
UserNote loadNote(Long userNoteId, Long serverId);
UserNote loadNote(Long serverId, Long userNoteId);
boolean noteExists(Long id, AServer server);
List<UserNote> loadNotesForUser(AUserInAServer aUserInAServer);
List<UserNote> loadNotesForServer(AServer server);

8
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emotes/command/handler/TrackedEmoteParameterHandlerTest.java
View File

@@ -59,7 +59,7 @@ public class TrackedEmoteParameterHandlerTest {
public void testHandleWithEmote() {
when(contextMessage.getGuild()).thenReturn(guild);
Emote emote = Mockito.mock(Emote.class);
UnparsedCommandParameterPiece input = UnparsedCommandParameterPiece.builder().value(WRONG_FORMATTED_INPUT).build();
UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(emote);
when(trackedEmoteService.getFakeTrackedEmote(emote, guild)).thenReturn(trackedEmote);
TrackedEmote parsedEmote = (TrackedEmote) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
@@ -70,7 +70,8 @@ public class TrackedEmoteParameterHandlerTest {
public void testHandleWithId() {
Long emoteId = 5L;
when(contextMessage.getGuild()).thenReturn(guild);
UnparsedCommandParameterPiece input = UnparsedCommandParameterPiece.builder().value(emoteId.toString()).build();
UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
when(input.getValue()).thenReturn(emoteId.toString());
when(trackedEmoteService.getFakeTrackedEmote(emoteId, guild)).thenReturn(trackedEmote);
when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
TrackedEmote parsedEmote = (TrackedEmote) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
@@ -80,7 +81,8 @@ public class TrackedEmoteParameterHandlerTest {
@Test(expected = NumberFormatException.class)
public void testWithIllegalInput() {
UnparsedCommandParameterPiece input = UnparsedCommandParameterPiece.builder().value(WRONG_FORMATTED_INPUT).build();
UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
when(input.getValue()).thenReturn(WRONG_FORMATTED_INPUT);
when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
}

8
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emotes/command/handler/TrackedEmoteParameterParameterHandlerTest.java
View File

@@ -62,7 +62,7 @@ public class TrackedEmoteParameterParameterHandlerTest {
public void testHandleWithEmote() {
when(contextMessage.getGuild()).thenReturn(guild);
Emote emote = Mockito.mock(Emote.class);
UnparsedCommandParameterPiece input = UnparsedCommandParameterPiece.builder().value(WRONG_FORMATTED_INPUT).build();
UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(emote);
when(trackedEmoteService.getFakeTrackedEmote(emote, guild)).thenReturn(trackedEmote);
TrackEmoteParameter parsedEmote = (TrackEmoteParameter) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
@@ -74,7 +74,8 @@ public class TrackedEmoteParameterParameterHandlerTest {
public void testHandleWithId() {
Long emoteId = 5L;
when(contextMessage.getGuild()).thenReturn(guild);
UnparsedCommandParameterPiece input = UnparsedCommandParameterPiece.builder().value(emoteId.toString()).build();
UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
when(input.getValue()).thenReturn(emoteId.toString());
when(trackedEmoteService.getFakeTrackedEmote(emoteId, guild)).thenReturn(trackedEmote);
when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
TrackEmoteParameter parsedEmote = (TrackEmoteParameter) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
@@ -84,7 +85,8 @@ public class TrackedEmoteParameterParameterHandlerTest {
@Test(expected = NumberFormatException.class)
public void testWithIllegalInput() {
UnparsedCommandParameterPiece input = UnparsedCommandParameterPiece.builder().value(WRONG_FORMATTED_INPUT).build();
UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
when(input.getValue()).thenReturn(WRONG_FORMATTED_INPUT);
when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
}

2
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/StarStatsTest.java
View File

@@ -36,7 +36,7 @@ public class StarStatsTest {
@Test
public void executeCommand() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
GuildStarStatsModel guildStarStatsModel = GuildStarStatsModel.builder().build();
GuildStarStatsModel guildStarStatsModel = Mockito.mock(GuildStarStatsModel.class);
when(starboardService.retrieveStarStats(noParameters.getGuild().getIdLong())).thenReturn(CompletableFuture.completedFuture(guildStarStatsModel));
CompletableFuture<CommandResult> result = testUnit.executeAsync(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInTextChannelList(StarStats.STARSTATS_RESPONSE_TEMPLATE, guildStarStatsModel, noParameters.getChannel());

4
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/remind/RemindersTest.java
View File

@@ -43,8 +43,8 @@ public class RemindersTest {
@Test
public void testExecuteCommand() {
CommandContext context = CommandTestUtilities.getNoParameters();
Reminder reminder = Reminder.builder().build();
Reminder secondReminder = Reminder.builder().build();
Reminder reminder = Mockito.mock(Reminder.class);
Reminder secondReminder = Mockito.mock(Reminder.class);
List<Reminder> reminders = Arrays.asList(reminder, secondReminder);
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadOrCreateUser(context.getAuthor())).thenReturn(user);

143
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/listener/embed/MessageEmbedListenerTest.java
View File

@@ -1,13 +1,11 @@
package dev.sheldan.abstracto.utility.listener.embed;
import dev.sheldan.abstracto.core.metrics.service.MetricService;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.models.MessageEmbedLink;
import dev.sheldan.abstracto.utility.service.MessageEmbedService;
import net.dv8tion.jda.api.entities.Guild;
@@ -32,14 +30,15 @@ import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class MessageEmbedListenerTest {
public static final long ORIGIN_GUILD_ID = 12L;
public static final long EMBEDDING_GUILD_ID = 13L;
@InjectMocks
private MessageEmbedListener testUnit;
@Mock
private MessageCache messageCache;
@Mock
private MetricService metricService;
@Mock
private UserInServerManagementService userInServerManagementService;
@@ -61,9 +60,16 @@ public class MessageEmbedListenerTest {
@Mock
private Guild guild;
private static final Long FIRST_SERVER_ID = 12L;
private static final Long SECOND_SERVER_ID = 13L;
private static final Long FIRST_CHANNEL_ID = 45L;
private static final Long USER_IN_SERVER_ID = 1L;
private static final Long FIRST_MESSAGE_ID = 2L;
private static final Long SECOND_MESSAGE_ID = 3L;
@Before
public void setup(){
when(guild.getIdLong()).thenReturn(ORIGIN_GUILD_ID);
when(guild.getIdLong()).thenReturn(FIRST_SERVER_ID);
when(message.getGuild()).thenReturn(guild);
when(message.getChannel()).thenReturn(textChannel);
}
@@ -82,7 +88,7 @@ public class MessageEmbedListenerTest {
public void testOnlyOneLinkFoundExecution() {
String linkText = "link";
String text = linkText;
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, ORIGIN_GUILD_ID);
executeLinkEmbedTest(linkText, text);
verify(self, times(1)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(messageService, times(1)).deleteMessage(message);
}
@@ -91,7 +97,7 @@ public class MessageEmbedListenerTest {
public void testOneLinkWithAdditionalTextExecution() {
String linkText = "link";
String text = linkText + "more text";
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, ORIGIN_GUILD_ID);
executeLinkEmbedTest(linkText, text);
verify(self, times(1)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(messageService, times(0)).deleteMessage(message);
}
@@ -100,7 +106,17 @@ public class MessageEmbedListenerTest {
public void testLinkFromDifferentServer() {
String linkText = "link";
String text = linkText + "more text";
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, EMBEDDING_GUILD_ID);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(message.getContentRaw()).thenReturn(text);
MessageEmbedLink foundLink = Mockito.mock(MessageEmbedLink.class);
when(foundLink.getMessageId()).thenReturn(FIRST_MESSAGE_ID);
when(foundLink.getServerId()).thenReturn(SECOND_SERVER_ID);
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(foundLink);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(userInAServer);
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(messageService, times(0)).deleteMessage(message);
verify(self, times(0)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
@@ -110,112 +126,89 @@ public class MessageEmbedListenerTest {
public void testTwoLinksOneGetsEmbedded() {
String firstText = "link";
String secondText = "secondLink";
AServer originServer = MockUtils.getServer(ORIGIN_GUILD_ID);
AServer embeddingServer = MockUtils.getServer(EMBEDDING_GUILD_ID);
AChannel originChannel = MockUtils.getTextChannel(originServer, 4L);
AChannel embeddingChannel = MockUtils.getTextChannel(embeddingServer, 7L);
Long messageId = 4L;
MessageEmbedLink differentOriginLink = MessageEmbedLink
.builder()
.serverId(originServer.getId())
.channelId(originChannel.getId())
.messageId(messageId)
.wholeUrl(firstText)
.build();
Long secondMessageId = 5L;
MessageEmbedLink sameServerLink = MessageEmbedLink
.builder()
.serverId(embeddingServer.getId())
.channelId(embeddingChannel.getId())
.messageId(secondMessageId)
.wholeUrl(secondText)
.build();
MessageEmbedLink differentOriginLink = Mockito.mock(MessageEmbedLink.class);
when(differentOriginLink.getServerId()).thenReturn(SECOND_SERVER_ID);
when(differentOriginLink.getMessageId()).thenReturn(SECOND_MESSAGE_ID);
MessageEmbedLink sameServerLink = Mockito.mock(MessageEmbedLink.class);
when(sameServerLink.getServerId()).thenReturn(FIRST_SERVER_ID);
when(sameServerLink.getChannelId()).thenReturn(FIRST_CHANNEL_ID);
when(sameServerLink.getMessageId()).thenReturn(FIRST_MESSAGE_ID);
when(sameServerLink.getWholeUrl()).thenReturn(secondText);
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(differentOriginLink, sameServerLink);
AUserInAServer embeddingUser = MockUtils.getUserObject(4L, embeddingServer);
AUserInAServer embeddingUser = Mockito.mock(AUserInAServer.class);
when(embeddingUser.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
String completeMessage = firstText.concat(secondText);
when(message.getContentRaw()).thenReturn(completeMessage);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(EMBEDDING_GUILD_ID);
when(guild.getIdLong()).thenReturn(FIRST_SERVER_ID);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(embeddingUser);
CachedMessage cachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(embeddingServer.getId(), embeddingChannel.getId(), secondMessageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, FIRST_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageEmbedService.getLinksInMessage(completeMessage)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(messageService, times(0)).deleteMessage(message);
verify(self, times(1)).embedSingleLink(message, embeddingUser.getUserInServerId(), cachedMessage);
verify(self, times(1)).embedSingleLink(message, USER_IN_SERVER_ID, cachedMessage);
}
@Test
public void testMultipleLinksFound() {
String text = "link";
AServer server = MockUtils.getServer(ORIGIN_GUILD_ID);
AChannel channel = MockUtils.getTextChannel(server, 4L);
Long messageId = 4L;
MessageEmbedLink foundLink = MessageEmbedLink
.builder()
.serverId(server.getId())
.channelId(channel.getId())
.messageId(messageId)
.wholeUrl(text)
.build();
Long secondMessageId = 5L;
MessageEmbedLink secondLink = MessageEmbedLink
.builder()
.serverId(server.getId())
.channelId(channel.getId())
.messageId(secondMessageId)
.wholeUrl(text)
.build();
MessageEmbedLink foundLink = Mockito.mock(MessageEmbedLink.class);
when(foundLink.getServerId()).thenReturn(FIRST_SERVER_ID);
when(foundLink.getChannelId()).thenReturn(FIRST_CHANNEL_ID);
when(foundLink.getMessageId()).thenReturn(FIRST_MESSAGE_ID);
when(foundLink.getWholeUrl()).thenReturn(text);
MessageEmbedLink secondLink = Mockito.mock(MessageEmbedLink.class);
when(secondLink.getServerId()).thenReturn(FIRST_SERVER_ID);
when(secondLink.getChannelId()).thenReturn(FIRST_CHANNEL_ID);
when(secondLink.getMessageId()).thenReturn(SECOND_MESSAGE_ID);
when(secondLink.getWholeUrl()).thenReturn(text);
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(foundLink, secondLink);
AUserInAServer userInAServer = MockUtils.getUserObject(4L, server);
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(userInAServer.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
when(message.getContentRaw()).thenReturn(text);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(userInAServer);
CachedMessage cachedMessage = CachedMessage.builder().build();
CachedMessage secondCachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(server.getId(), channel.getId(), messageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageCache.getMessageFromCache(server.getId(), channel.getId(), secondMessageId)).thenReturn(CompletableFuture.completedFuture(secondCachedMessage));
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
CachedMessage secondCachedMessage = Mockito.mock(CachedMessage.class);
when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, FIRST_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, SECOND_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(secondCachedMessage));
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(messageService, times(1)).deleteMessage(message);
verify(self, times(1)).embedSingleLink(message, userInAServer.getUserInServerId(), cachedMessage);
verify(self, times(1)).embedSingleLink(message, userInAServer.getUserInServerId(), secondCachedMessage);
verify(self, times(1)).embedSingleLink(message, USER_IN_SERVER_ID, cachedMessage);
verify(self, times(1)).embedSingleLink(message, USER_IN_SERVER_ID, secondCachedMessage);
}
@Test
public void testLoadUserAndEmbed() {
CachedMessage cachedMessage = CachedMessage.builder().build();
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
long userId = 3L;
when(message.getTextChannel()).thenReturn(textChannel);
when(messageEmbedService.embedLink(cachedMessage, textChannel, userId, message)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.embedSingleLink(message, userId, cachedMessage);
verify(metricService, times(1)).incrementCounter(any());
}
private void executeLinkTestForOneLink(String text, String linkText, Long originServerId, Long embeddingServerId) {
AServer originServer = MockUtils.getServer(originServerId);
AServer embeddingServer = MockUtils.getServer(embeddingServerId);
AChannel channel = MockUtils.getTextChannel(embeddingServer, 4L);
AUserInAServer userInAServer = MockUtils.getUserObject(4L, embeddingServer);
private void executeLinkEmbedTest(String linkText, String text) {
AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
when(message.getContentRaw()).thenReturn(text);
Long messageId = 4L;
MessageEmbedLink foundLink = MessageEmbedLink
.builder()
.serverId(embeddingServer.getId())
.channelId(channel.getId())
.messageId(messageId)
.wholeUrl(linkText)
.build();
MessageEmbedLink foundLink = Mockito.mock(MessageEmbedLink.class);
when(foundLink.getWholeUrl()).thenReturn(linkText);
when(foundLink.getMessageId()).thenReturn(FIRST_MESSAGE_ID);
when(foundLink.getServerId()).thenReturn(FIRST_SERVER_ID);
when(foundLink.getChannelId()).thenReturn(FIRST_CHANNEL_ID);
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(foundLink);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(userInAServer);
CachedMessage cachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(originServer.getId(), channel.getId(), messageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, FIRST_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
}

33
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/listener/embed/MessageEmbedRemovalReactionListenerTest.java
View File

@@ -111,21 +111,17 @@ public class MessageEmbedRemovalReactionListenerTest {
}
private void executeDeletionTest(AUserInAServer embeddingUser, AUserInAServer embeddedUser, ServerUser userAddingReaction, int wantedDeletions) {
CachedMessage cachedMessage = CachedMessage
.builder()
.serverId(SERVER_ID)
.messageId(MESSAGE_ID)
.channelId(CHANNEL_ID)
.build();
AEmote reactedEmote = AEmote.builder().build();
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getChannelId()).thenReturn(CHANNEL_ID);
when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
AEmote reactedEmote = Mockito.mock(AEmote.class);
when(emoteService.getEmoteOrDefaultEmote(MessageEmbedRemovalReactionListener.REMOVAL_EMOTE, SERVER_ID)).thenReturn(reactedEmote);
when(messageReaction.getEmote()).thenReturn(reactionEmote);
when(emoteService.compareCachedEmoteWithAEmote(reactionEmote, reactedEmote)).thenReturn(true);
EmbeddedMessage message = EmbeddedMessage
.builder()
.embeddingUser(embeddingUser)
.embeddedUser(embeddedUser)
.build();
EmbeddedMessage message = Mockito.mock(EmbeddedMessage.class);
when(message.getEmbeddingUser()).thenReturn(embeddingUser);
when(message.getEmbeddedUser()).thenReturn(embeddedUser);
when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(MESSAGE_ID)).thenReturn(Optional.of(message));
when(messageService.deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(MESSAGE_ID)).thenReturn(Optional.of(message));
@@ -137,19 +133,16 @@ public class MessageEmbedRemovalReactionListenerTest {
}
private void executeRemovalEmoteAddedTest(boolean wasCorrectEmote) {
CachedMessage cachedMessage = CachedMessage
.builder()
.serverId(SERVER_ID)
.messageId(MESSAGE_ID)
.channelId(CHANNEL_ID)
.build();
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
ServerUser serverUser = Mockito.mock(ServerUser.class);
AEmote reactedEmote = AEmote.builder().build();
AEmote reactedEmote = Mockito.mock(AEmote.class);
when(emoteService.getEmoteOrDefaultEmote(MessageEmbedRemovalReactionListener.REMOVAL_EMOTE, SERVER_ID)).thenReturn(reactedEmote);
when(messageReaction.getEmote()).thenReturn(reactionEmote);
when(emoteService.compareCachedEmoteWithAEmote(reactionEmote, reactedEmote)).thenReturn(wasCorrectEmote);
testUnit.executeReactionAdded(cachedMessage, messageReaction, serverUser);
verify(messageService, times(0)).deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, MESSAGE_ID);
verify(messageService, times(0)).deleteMessageInChannelInServer(anyLong(), anyLong(), anyLong());
}
}

4
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/listener/starboard/StarboardListenerTest.java
View File

@@ -254,7 +254,9 @@ public class StarboardListenerTest {
if(!remainingUsers.isEmpty()) {
when(userInServerManagementService.loadUserOptional(SERVER_ID, USER_ACTING_ID)).thenReturn(Optional.of(userInServerActing));
}
when(configManagementService.loadConfig(SERVER_ID, StarboardListener.FIRST_LEVEL_THRESHOLD_KEY)).thenReturn(AConfig.builder().longValue(requiredStars).build());
AConfig starRequirementConfig = Mockito.mock(AConfig.class);
when(starRequirementConfig.getLongValue()).thenReturn(requiredStars);
when(configManagementService.loadConfig(SERVER_ID, StarboardListener.FIRST_LEVEL_THRESHOLD_KEY)).thenReturn(starRequirementConfig);
testUnit.executeReactionRemoved(cachedMessage, cachedReaction, serverUserActing);
verify(emoteService, times(1)).getEmoteOrDefaultEmote(STAR_EMOTE, SERVER_ID);
verify(emoteService, times(1)).getReactionFromMessageByEmote(cachedMessage, starEmote);

8
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/MessageEmbedServiceBeanTest.java
View File

@@ -160,8 +160,12 @@ public class MessageEmbedServiceBeanTest {
List<MessageEmbedLink> linksToEmbed = new ArrayList<>();
Long channelId = 6L;
Long firstMessageId = 6L;
linksToEmbed.add(MessageEmbedLink.builder().serverId(SERVER_ID).channelId(channelId).messageId(firstMessageId).build());
CachedMessage firstCachedMessage = CachedMessage.builder().serverId(SERVER_ID).channelId(channelId).messageId(firstMessageId).build();
MessageEmbedLink messageEmbedLink = Mockito.mock(MessageEmbedLink.class);
when(messageEmbedLink.getServerId()).thenReturn(SERVER_ID);
when(messageEmbedLink.getChannelId()).thenReturn(channelId);
when(messageEmbedLink.getMessageId()).thenReturn(firstMessageId);
linksToEmbed.add(messageEmbedLink);
CachedMessage firstCachedMessage = Mockito.mock(CachedMessage.class);
when(messageCache.getMessageFromCache(SERVER_ID,channelId, firstMessageId)).thenReturn(CompletableFuture.completedFuture(firstCachedMessage));
Long embeddingUserId = 5L;
testUnit.embedLinks(linksToEmbed, textChannel, embeddingUserId, embeddingMessage);

153
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/RemindServiceBeanTest.java
View File

@@ -9,7 +9,6 @@ import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.GuildService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.scheduling.service.SchedulerService;
import dev.sheldan.abstracto.core.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.templating.service.TemplateService;
@@ -66,7 +65,7 @@ public class RemindServiceBeanTest {
private MemberService memberService;
@Mock
private ReminderService self;
private RemindServiceBean self;
@Mock
private ChannelService channelService;
@@ -80,7 +79,22 @@ public class RemindServiceBeanTest {
@Mock
private ScheduledExecutorService instantReminderScheduler;
@Mock
private AServer server;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AUser user;
@Mock
private AChannel aChannel;
private static final Long REMINDER_ID = 5L;
private static final Long CHANNEL_ID = 6L;
private static final Long SERVER_ID = 8L;
private static final Long USER_ID = 9L;
@Before
public void setup() {
@@ -91,37 +105,39 @@ public class RemindServiceBeanTest {
@Test
public void createReminderWithScheduler() {
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(4L, server);
AChannel aChannel = MockUtils.getTextChannel(server, 5L);
String remindText = "text";
String triggerKey = "trigger";
Duration duration = Duration.ofSeconds(62);
when(channelManagementService.loadChannel(channel.getIdLong())).thenReturn(aChannel);
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(REMINDER_ID).build();
when(message.getChannel()).thenReturn(channel);
when(channel.getIdLong()).thenReturn(CHANNEL_ID);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(aChannel);
Instant targetDate = Instant.now().plus(duration);
Reminder createdReminder = Mockito.mock(Reminder.class);
when(createdReminder.getTargetDate()).thenReturn(targetDate);
Long messageId = 5L;
when(reminderManagementService.createReminder(any(AServerAChannelAUser.class), eq(remindText), any(Instant.class), eq(messageId))).thenReturn(createdReminder);
String triggerKey = "trigger";
when(schedulerService.executeJobWithParametersOnce(eq("reminderJob"), eq("utility"), any(JobDataMap.class), eq(Date.from(createdReminder.getTargetDate())))).thenReturn(triggerKey);
Reminder returnedReminder = testUnit.createReminderInForUser(user, remindText, duration, message);
createdReminder.setJobTriggerKey(triggerKey);
when(schedulerService.executeJobWithParametersOnce(eq("reminderJob"), eq("utility"), any(JobDataMap.class), eq(Date.from(targetDate)))).thenReturn(triggerKey);
Reminder returnedReminder = testUnit.createReminderInForUser(aUserInAServer, remindText, duration, message);
verify(reminderManagementService, times(1)).saveReminder(createdReminder);
Assert.assertEquals(remindText, returnedReminder.getText());
Assert.assertEquals(createdReminder.getId(), returnedReminder.getId());
Assert.assertEquals(triggerKey, returnedReminder.getJobTriggerKey());
Assert.assertEquals(createdReminder, returnedReminder);
}
@Test
public void createReminderWithoutScheduler() {
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(4L, server);
AChannel aChannel = MockUtils.getTextChannel(server, 5L);
String remindText = "text";
Duration duration = Duration.ofSeconds(50);
when(channelManagementService.loadChannel(channel.getIdLong())).thenReturn(aChannel);
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(REMINDER_ID).build();
when(message.getChannel()).thenReturn(channel);
when(channel.getIdLong()).thenReturn(CHANNEL_ID);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(aChannel);
Reminder createdReminder = Mockito.mock(Reminder.class);
when(createdReminder.getText()).thenReturn(remindText);
Long messageId = 5L;
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.createReminder(any(AServerAChannelAUser.class), eq(remindText), any(Instant.class), eq(messageId))).thenReturn(createdReminder);
Reminder returnedReminder = testUnit.createReminderInForUser(user, remindText, duration, message);
Reminder returnedReminder = testUnit.createReminderInForUser(aUserInAServer, remindText, duration, message);
verify(reminderManagementService, times(0)).saveReminder(createdReminder);
Assert.assertEquals(remindText, returnedReminder.getText());
Assert.assertEquals(createdReminder.getId(), returnedReminder.getId());
@@ -129,93 +145,94 @@ public class RemindServiceBeanTest {
@Test
public void testExecuteReminder() {
AServer server = MockUtils.getServer();
AChannel aChannel = MockUtils.getTextChannel(server, 4L);
AUserInAServer remindedUser = MockUtils.getUserObject(5L, server);
Reminder remindedReminder = Reminder.builder().reminded(false).remindedUser(remindedUser).reminderDate(Instant.now()).targetDate(Instant.now()).server(server).channel(aChannel).id(REMINDER_ID).build();
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getRemindedUser()).thenReturn(aUserInAServer);
when(remindedReminder.getChannel()).thenReturn(aChannel);
when(remindedReminder.getServer()).thenReturn(server);
when(aChannel.getId()).thenReturn(CHANNEL_ID);
when(server.getId()).thenReturn(SERVER_ID);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(user.getId()).thenReturn(USER_ID);
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
Guild guildMock = Mockito.mock(Guild.class);
when(guildService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(channelService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.of(channel));
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(guildMock));
when(channelService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.of(channel));
Member mockedMember = Mockito.mock(Member.class);
when(memberService.getMemberInServerAsync(server.getId(), remindedUser.getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(mockedMember));
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(mockedMember));
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@Test
public void testExecuteReminderFromNotFoundChannel() {
AServer server = MockUtils.getServer();
AChannel aChannel = MockUtils.getTextChannel(server, 4L);
AUserInAServer remindedUser = Mockito.mock(AUserInAServer.class);
AUser user = Mockito.mock(AUser.class);
when(user.getId()).thenReturn(6L);
when(remindedUser.getUserReference()).thenReturn(user);
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).remindedUser(remindedUser).channel(aChannel).id(REMINDER_ID).build();
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getChannel()).thenReturn(aChannel);
when(remindedReminder.getServer()).thenReturn(server);
when(server.getId()).thenReturn(SERVER_ID);
when(aChannel.getId()).thenReturn(CHANNEL_ID);
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
Guild guildMock = Mockito.mock(Guild.class);
when(guildService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(channelService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.empty());
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(guildMock));
when(aUserInAServer.getUserReference()).thenReturn(user);
when(remindedReminder.getRemindedUser()).thenReturn(aUserInAServer);
when(channelService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.empty());
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
verify(self, times(0)).sendReminderText(anyLong(), any(), any(Member.class));
}
@Test
public void testExecuteReminderFromNotFoundGuild() {
AServer server = MockUtils.getServer();
AChannel aChannel = Mockito.mock(AChannel.class);
when(aChannel.getId()).thenReturn(9L);
Long reminderId = 5L;
AUserInAServer remindedUser = Mockito.mock(AUserInAServer.class);
AUser user = Mockito.mock(AUser.class);
when(user.getId()).thenReturn(6L);
when(remindedUser.getUserReference()).thenReturn(user);
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).channel(aChannel).remindedUser(remindedUser).id(reminderId).build();
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getChannel()).thenReturn(aChannel);
when(remindedReminder.getServer()).thenReturn(server);
when(server.getId()).thenReturn(SERVER_ID);
when(remindedReminder.getRemindedUser()).thenReturn(aUserInAServer);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.loadReminder(reminderId)).thenReturn(remindedReminder);
when(guildService.getGuildByIdOptional(server.getId())).thenReturn(Optional.empty());
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@Test
public void testExecuteRemindedReminder() {
Long reminderId = 5L;
Reminder remindedReminder = Reminder.builder().reminded(true).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(remindedReminder);
testUnit.executeReminder(reminderId);
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.isReminded()).thenReturn(true);
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
testUnit.executeReminder(REMINDER_ID);
verify(guildService, times(0)).getGuildByIdOptional(anyLong());
}
@Test
public void testUnRemindScheduledReminder() {
AServer server = MockUtils.getServer();
AUserInAServer remindedUser = MockUtils.getUserObject(5L, server);
Long reminderId = 5L;
String triggerKey = "trigger";
Reminder reminderToUnRemind = Reminder.builder().jobTriggerKey(triggerKey).id(reminderId).build();
when(reminderManagementService.getReminderByAndByUserNotReminded(remindedUser, reminderId)).thenReturn(Optional.of(reminderToUnRemind));
testUnit.unRemind(reminderId, remindedUser);
Reminder reminderToUnRemind = Mockito.mock(Reminder.class);
when(reminderToUnRemind.getJobTriggerKey()).thenReturn(triggerKey);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID)).thenReturn(Optional.of(reminderToUnRemind));
testUnit.unRemind(REMINDER_ID, aUserInAServer);
verify(schedulerService, times(1)).stopTrigger(triggerKey);
}
@Test
public void testUnRemindNonScheduledReminder() {
AServer server = MockUtils.getServer();
AUserInAServer remindedUser = MockUtils.getUserObject(5L, server);
Long reminderId = 5L;
Reminder reminderToUnRemind = Reminder.builder().id(reminderId).build();
when(reminderManagementService.getReminderByAndByUserNotReminded(remindedUser, reminderId)).thenReturn(Optional.of(reminderToUnRemind));
testUnit.unRemind(reminderId, remindedUser);
Reminder reminderToUnRemind = Mockito.mock(Reminder.class);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID)).thenReturn(Optional.of(reminderToUnRemind));
testUnit.unRemind(REMINDER_ID, aUserInAServer);
verify(schedulerService, times(0)).stopTrigger(anyString());
}
@Test(expected = ReminderNotFoundException.class)
public void testUnRemindNonExistingReminder() {
AServer server = MockUtils.getServer();
AUserInAServer remindedUser = MockUtils.getUserObject(5L, server);
Long reminderId = 5L;
when(reminderManagementService.getReminderByAndByUserNotReminded(remindedUser, reminderId)).thenReturn(Optional.empty());
testUnit.unRemind(reminderId, remindedUser);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID)).thenReturn(Optional.empty());
testUnit.unRemind(REMINDER_ID, aUserInAServer);
}
@Test
@@ -232,7 +249,9 @@ public class RemindServiceBeanTest {
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(REMINDER_TEMPLATE_TEXT), any())).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, channel)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
testUnit.sendReminderText(REMINDER_ID, channel, remindedMember).join();
CompletableFuture<Void> future = testUnit.sendReminderText(REMINDER_ID, channel, remindedMember);
future.join();
Assert.assertFalse(future.isCompletedExceptionally());
}
}

38
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/SuggestionServiceBeanTest.java
View File

@@ -109,7 +109,7 @@ public class SuggestionServiceBeanTest {
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(serverManagementService.loadServer(suggestionCreator.getGuild())).thenReturn(server);
MessageToSend messageToSend = MessageToSend.builder().build();
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class))).thenReturn(messageToSend);
Message suggestionMessage = Mockito.mock(Message.class);
when(counterService.getNextCounterValue(server, SUGGESTION_COUNTER_KEY)).thenReturn(SUGGESTION_ID);
@@ -162,14 +162,14 @@ public class SuggestionServiceBeanTest {
private void setupForNoTextChannel() {
Long messageId = 7L;
Suggestion suggestionToAccept = Suggestion
.builder()
.channel(channel)
.server(server)
.suggestionId(new ServerSpecificId(server.getId(), SUGGESTION_ID))
.suggester(suggester)
.messageId(messageId)
.build();
Suggestion suggestionToAccept = Mockito.mock(Suggestion.class);
when(suggestionToAccept.getChannel()).thenReturn(channel);
when(suggestionToAccept.getServer()).thenReturn(server);
when(suggestionToAccept.getSuggester()).thenReturn(suggester);
ServerSpecificId suggestionId = Mockito.mock(ServerSpecificId.class);
when(suggestionId.getId()).thenReturn(SUGGESTION_ID);
when(suggestionToAccept.getSuggestionId()).thenReturn(suggestionId);
when(suggestionToAccept.getMessageId()).thenReturn(messageId);
when(server.getId()).thenReturn(SERVER_ID);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(channelService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenThrow(new ChannelNotInGuildException(CHANNEL_ID));
@@ -178,7 +178,7 @@ public class SuggestionServiceBeanTest {
@Test(expected = SuggestionUpdateException.class)
public void testUpdateSuggestionTextWithoutEmbed() {
SuggestionLog log = SuggestionLog.builder().build();
SuggestionLog log = Mockito.mock(SuggestionLog.class);
Message suggestionMessage = Mockito.mock(Message.class);
testUnit.updateSuggestionMessageText(CLOSING_TEXT, log, suggestionMessage);
}
@@ -193,7 +193,7 @@ public class SuggestionServiceBeanTest {
when(suggestionMessage.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(suggestionMessage.getEmbeds()).thenReturn(Arrays.asList(embed));
MessageToSend updatedMessage = MessageToSend.builder().build();
MessageToSend updatedMessage = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class))).thenReturn(updatedMessage);
testUnit.updateSuggestionMessageText(CLOSING_TEXT, log, suggestionMessage);
verify(postTargetService, times(1)).sendEmbedInPostTarget(updatedMessage, SuggestionPostTarget.SUGGESTION, SERVER_ID);
@@ -254,14 +254,14 @@ public class SuggestionServiceBeanTest {
}
private Suggestion setupClosing(Long messageId) {
Suggestion suggestionToAccept = Suggestion
.builder()
.channel(channel)
.server(server)
.suggestionId(new ServerSpecificId(server.getId(), SUGGESTION_ID))
.suggester(suggester)
.messageId(messageId)
.build();
Suggestion suggestionToAccept = Mockito.mock(Suggestion.class);
when(suggestionToAccept.getChannel()).thenReturn(channel);
when(suggestionToAccept.getServer()).thenReturn(server);
when(suggestionToAccept.getSuggester()).thenReturn(suggester);
ServerSpecificId suggestionId = Mockito.mock(ServerSpecificId.class);
when(suggestionId.getId()).thenReturn(SUGGESTION_ID);
when(suggestionToAccept.getSuggestionId()).thenReturn(suggestionId);
when(suggestionToAccept.getMessageId()).thenReturn(messageId);
when(server.getId()).thenReturn(SERVER_ID);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(suggester.getUserReference()).thenReturn(suggesterUser);

22
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/management/MessageEmbedPostManagementServiceBeanTest.java
View File

@@ -8,7 +8,6 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.exception.CrossServerEmbedException;
import dev.sheldan.abstracto.utility.models.database.EmbeddedMessage;
import dev.sheldan.abstracto.utility.repository.EmbeddedMessageRepository;
@@ -98,19 +97,20 @@ public class MessageEmbedPostManagementServiceBeanTest {
@Test(expected = CrossServerEmbedException.class)
public void testToCreateEmbedForDifferentServers() {
AServer originalServer = MockUtils.getServer(7L);
AServer embeddingServer = MockUtils.getServer(9L);
AUserInAServer embeddingUser = MockUtils.getUserObject(5L, embeddingServer);
when(serverManagementService.loadOrCreate(embeddingServer.getId())).thenReturn(embeddingServer);
when(serverManagementService.loadOrCreate(originalServer.getId())).thenReturn(originalServer);
CachedMessage cachedMessage = CachedMessage
.builder()
.serverId(originalServer.getId())
.build();
Long originServerId = 4L;
AServer originalServer = Mockito.mock(AServer.class);
when(originalServer.getId()).thenReturn(originServerId);
AServer embeddingServer = Mockito.mock(AServer.class);
when(embeddingServer.getId()).thenReturn(SERVER_ID);
AUserInAServer embeddingUser = Mockito.mock(AUserInAServer.class);
when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(embeddingServer);
when(serverManagementService.loadOrCreate(originServerId)).thenReturn(originalServer);
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(cachedMessage.getServerId()).thenReturn(originServerId);
Message message = Mockito.mock(Message.class);
Guild guild = Mockito.mock(Guild.class);
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(embeddingServer.getId());
when(guild.getIdLong()).thenReturn(SERVER_ID);
testUnit.createMessageEmbed(cachedMessage, message, embeddingUser);
}

97
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/management/ReminderManagementServiceBeanTest.java
View File

@@ -3,8 +3,8 @@ package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
import dev.sheldan.abstracto.core.models.database.AChannel;
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.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.repository.ReminderRepository;
import org.junit.Assert;
@@ -12,6 +12,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Instant;
@@ -30,60 +31,64 @@ public class ReminderManagementServiceBeanTest {
@Mock
private ReminderRepository reminderRepository;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AChannel channel;
@Mock
private AServer server;
@Mock
private Reminder reminder;
private static final Long REMINDER_ID = 8L;
@Test
public void testCreateReminder() {
AServer server = MockUtils.getServer();
AUserInAServer toBeReminded = MockUtils.getUserObject(5L, server);
AChannel channel = MockUtils.getTextChannel(server, 6L);
AServerAChannelAUser serverAChannelAUser = AServerAChannelAUser
.builder()
.aUserInAServer(toBeReminded)
.channel(channel)
.guild(server)
.build();
AServerAChannelAUser serverAChannelAUser = Mockito.mock(AServerAChannelAUser.class);
AUser user = Mockito.mock(AUser.class);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(serverAChannelAUser.getAUserInAServer()).thenReturn(aUserInAServer);
when(serverAChannelAUser.getGuild()).thenReturn(server);
when(serverAChannelAUser.getChannel()).thenReturn(channel);
String reminderText = "text";
Instant reminderTargetDate = Instant.ofEpochSecond(1590615937);
Long messageId = 5L;
Reminder reminder = testUnit.createReminder(serverAChannelAUser, reminderText, reminderTargetDate, messageId);
Assert.assertEquals(messageId, reminder.getMessageId());
Assert.assertEquals(toBeReminded.getUserReference().getId(), reminder.getRemindedUser().getUserReference().getId());
Assert.assertEquals(toBeReminded.getUserInServerId(), reminder.getRemindedUser().getUserInServerId());
Assert.assertEquals(server.getId(), reminder.getServer().getId());
Assert.assertEquals(server.getId(), reminder.getRemindedUser().getServerReference().getId());
Assert.assertEquals(reminderText, reminder.getText());
Assert.assertEquals(reminderTargetDate, reminder.getTargetDate());
Assert.assertEquals(channel.getId(), reminder.getChannel().getId());
Assert.assertFalse(reminder.isReminded());
verify(reminderRepository, times(1)).save(reminder);
Reminder createdReminder = testUnit.createReminder(serverAChannelAUser, reminderText, reminderTargetDate, messageId);
Assert.assertEquals(messageId, createdReminder.getMessageId());
Assert.assertEquals(aUserInAServer, createdReminder.getRemindedUser());
Assert.assertEquals(server, createdReminder.getServer());
Assert.assertEquals(reminderText, createdReminder.getText());
Assert.assertEquals(reminderTargetDate, createdReminder.getTargetDate());
Assert.assertEquals(channel, createdReminder.getChannel());
Assert.assertFalse(createdReminder.isReminded());
verify(reminderRepository, times(1)).save(createdReminder);
}
@Test
public void testSetReminded() {
Reminder reminder = Reminder.builder().build();
testUnit.setReminded(reminder);
reminder.setReminded(true);
verify(reminder, times(1)).setReminded(true);
verify(reminderRepository, times(1)).save(reminder);
}
@Test
public void testSaveReminder() {
Reminder reminder = Reminder.builder().build();
testUnit.saveReminder(reminder);
verify(reminderRepository, times(1)).save(reminder);
}
@Test
public void testRetrieveActiveReminders() {
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(5L, server);
Reminder reminder1 = Reminder.builder().build();
Reminder reminder2 = Reminder.builder().build();
List<Reminder> reminders = Arrays.asList(reminder1, reminder2);
when(reminderRepository.getByRemindedUserAndRemindedFalse(user)).thenReturn(reminders);
List<Reminder> activeRemindersForUser = testUnit.getActiveRemindersForUser(user);
Reminder reminder2 = Mockito.mock(Reminder.class);
List<Reminder> reminders = Arrays.asList(reminder, reminder2);
when(reminderRepository.getByRemindedUserAndRemindedFalse(aUserInAServer)).thenReturn(reminders);
List<Reminder> activeRemindersForUser = testUnit.getActiveRemindersForUser(aUserInAServer);
for (int i = 0; i < reminders.size(); i++) {
Reminder reference = reminders.get(i);
Reminder returned = activeRemindersForUser.get(0);
Reminder returned = activeRemindersForUser.get(i);
Assert.assertEquals(reference, returned);
}
Assert.assertEquals(reminders.size(), activeRemindersForUser.size());
@@ -91,41 +96,31 @@ public class ReminderManagementServiceBeanTest {
@Test
public void testGetReminderByIdAndNotReminded() {
Long reminderId = 6L;
Reminder reminder = Reminder.builder().id(6L).build();
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(5L, server);
when(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(reminderId, user)).thenReturn(reminder);
Optional<Reminder> returned = testUnit.getReminderByAndByUserNotReminded(user, reminderId);
when(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(REMINDER_ID, aUserInAServer)).thenReturn(reminder);
Optional<Reminder> returned = testUnit.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID);
Assert.assertTrue(returned.isPresent());
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminder, returnedReminder));
}
@Test
public void testGetReminderByIdAndNotRemindedNothingFound() {
Long reminderId = 6L;
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(5L, server);
when(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(reminderId, user)).thenReturn(null);
Optional<Reminder> returned = testUnit.getReminderByAndByUserNotReminded(user, reminderId);
when(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(REMINDER_ID, aUserInAServer)).thenReturn(null);
Optional<Reminder> returned = testUnit.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID);
Assert.assertFalse(returned.isPresent());
}
@Test
public void testLoadingReminder() {
Long reminderId = 5L;
Reminder reminderToLoad = Reminder.builder().build();
when(reminderRepository.findById(reminderId)).thenReturn(Optional.of(reminderToLoad));
Optional<Reminder> returned = testUnit.loadReminderOptional(reminderId);
when(reminderRepository.findById(REMINDER_ID)).thenReturn(Optional.of(reminder));
Optional<Reminder> returned = testUnit.loadReminderOptional(REMINDER_ID);
Assert.assertTrue(returned.isPresent());
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminderToLoad, returnedReminder));
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminder, returnedReminder));
}
@Test
public void testLoadingReminderNotFound() {
Long reminderId = 5L;
when(reminderRepository.findById(reminderId)).thenReturn(Optional.empty());
Optional<Reminder> returned = testUnit.loadReminderOptional(reminderId);
when(reminderRepository.findById(REMINDER_ID)).thenReturn(Optional.empty());
Optional<Reminder> returned = testUnit.loadReminderOptional(REMINDER_ID);
Assert.assertFalse(returned.isPresent());
}

115
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/management/StarboardPostManagementServiceBeanTest.java
View File

@@ -4,9 +4,9 @@ import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AChannel;
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.ChannelManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.models.database.StarboardPostReaction;
import dev.sheldan.abstracto.utility.repository.StarboardPostRepository;
@@ -15,6 +15,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
@@ -36,60 +37,67 @@ public class StarboardPostManagementServiceBeanTest {
@Mock
private ChannelManagementService channelManagementService;
@Mock
private AServer server;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AChannel sourceChannel;
@Mock
private AChannel starboardChannel;
private static final Long SOURCE_CHANNEL_ID = 5L;
private static final Long SERVER_ID = 7L;
@Test
public void testCreateStarboardPost() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(7L, server);
AChannel sourceChannel = MockUtils.getTextChannel(server, 9L);
AChannel starboardChannel = MockUtils.getTextChannel(server, 10L);
Long starboardPostId = 5L;
Long starredMessageId = 8L;
CachedMessage starredMessage = CachedMessage
.builder()
.channelId(sourceChannel.getId())
.messageId(starredMessageId)
.serverId(server.getId())
.build();
AServerAChannelMessage postInStarboard = AServerAChannelMessage
.builder()
.server(server)
.channel(starboardChannel)
.messageId(starboardPostId)
.build();
when(channelManagementService.loadChannel(starredMessage.getChannelId())).thenReturn(sourceChannel);
StarboardPost createdStarboardPost = testUnit.createStarboardPost(starredMessage, userInAServer, postInStarboard);
CachedMessage starredMessage = Mockito.mock(CachedMessage.class);
when(starredMessage.getServerId()).thenReturn(SERVER_ID);
when(starredMessage.getChannelId()).thenReturn(SOURCE_CHANNEL_ID);
when(starredMessage.getMessageId()).thenReturn(starredMessageId);
AServerAChannelMessage postInStarboard = Mockito.mock(AServerAChannelMessage.class);
when(postInStarboard.getServer()).thenReturn(server);
when(postInStarboard.getChannel()).thenReturn(starboardChannel);
when(postInStarboard.getMessageId()).thenReturn(starboardPostId);
when(channelManagementService.loadChannel(SOURCE_CHANNEL_ID)).thenReturn(sourceChannel);
AUser aUser = Mockito.mock(AUser.class);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
StarboardPost createdStarboardPost = testUnit.createStarboardPost(starredMessage, aUserInAServer, postInStarboard);
verify(repository, times(1)).save(createdStarboardPost);
Assert.assertEquals(postInStarboard.getChannel().getId(), createdStarboardPost.getStarboardChannel().getId());
Assert.assertEquals(postInStarboard.getServer().getId(), createdStarboardPost.getStarboardChannel().getServer().getId());
Assert.assertEquals(starboardChannel, createdStarboardPost.getStarboardChannel());
Assert.assertEquals(starboardPostId, createdStarboardPost.getStarboardMessageId());
Assert.assertEquals(starredMessageId, createdStarboardPost.getPostMessageId());
Assert.assertEquals(userInAServer.getUserInServerId(), createdStarboardPost.getAuthor().getUserInServerId());
Assert.assertEquals(sourceChannel.getId(), createdStarboardPost.getSourceChannel().getId());
Assert.assertEquals(aUserInAServer, createdStarboardPost.getAuthor());
Assert.assertEquals(sourceChannel, createdStarboardPost.getSourceChannel());
Assert.assertFalse(createdStarboardPost.isIgnored());
}
@Test
public void setStarboardMessageId(){
StarboardPost post = StarboardPost
.builder()
.build();
StarboardPost post = Mockito.mock(StarboardPost.class);
Long messageId = 6L;
testUnit.setStarboardPostMessageId(post, messageId);
Assert.assertEquals(messageId, post.getStarboardMessageId());
verify(post, times(1)).setStarboardMessageId(messageId);
verify(repository, times(1)).save(post);
}
@Test
public void testRetrieveTopPosts() {
AServer server = MockUtils.getServer();
Integer count = 2;
StarboardPostReaction reaction = StarboardPostReaction.builder().build();
StarboardPost starboardPost1 = StarboardPost.builder().reactions(Arrays.asList(reaction, reaction)).build();
StarboardPost starboardPost2 = StarboardPost.builder().reactions(Arrays.asList(reaction)).build();
StarboardPost starboardPost3 = StarboardPost.builder().reactions(new ArrayList<>()).build();
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
when(starboardPost1.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class), Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
when(starboardPost2.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost3 = Mockito.mock(StarboardPost.class);
when(starboardPost3.getReactions()).thenReturn(new ArrayList<>());
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2, starboardPost3);
when(repository.findByServer_Id(server.getId())).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(server.getId(), count);
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(SERVER_ID, count);
Assert.assertEquals(count.intValue(), topPosts.size());
StarboardPost topMostPost = topPosts.get(0);
StarboardPost secondTop = topPosts.get(1);
@@ -100,15 +108,16 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRetrieveMoreThanAvailable() {
AServer server = MockUtils.getServer();
Integer count = 5;
StarboardPostReaction reaction = StarboardPostReaction.builder().build();
StarboardPost starboardPost1 = StarboardPost.builder().reactions(Arrays.asList(reaction, reaction)).build();
StarboardPost starboardPost2 = StarboardPost.builder().reactions(Arrays.asList(reaction)).build();
StarboardPost starboardPost3 = StarboardPost.builder().reactions(new ArrayList<>()).build();
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
when(starboardPost1.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class), Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
when(starboardPost2.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost3 = Mockito.mock(StarboardPost.class);
when(starboardPost3.getReactions()).thenReturn(new ArrayList<>());
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2, starboardPost3);
when(repository.findByServer_Id(server.getId())).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(server.getId(), count);
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(SERVER_ID, count);
StarboardPost topMostPost = topPosts.get(0);
StarboardPost secondTop = topPosts.get(1);
StarboardPost thirdTopMostPost = topPosts.get(2);
@@ -122,10 +131,9 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRemovePost() {
StarboardPostReaction reaction = StarboardPostReaction.builder().build();
StarboardPost starboardPost = StarboardPost.builder().reactions(new ArrayList<>(Arrays.asList(reaction, reaction))).build();
testUnit.removePost(starboardPost);
Assert.assertEquals(0, starboardPost.getReactions().size());
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
when(starboardPost1.getReactions()).thenReturn(new ArrayList<>(Arrays.asList(Mockito.mock(StarboardPostReaction.class), Mockito.mock(StarboardPostReaction.class))));
testUnit.removePost(starboardPost1);
verify(repository, times(1)).delete(any(StarboardPost.class));
}
@@ -133,10 +141,10 @@ public class StarboardPostManagementServiceBeanTest {
public void testSetStarboardPostIgnored() {
Long messageId = 5L;
Boolean ignoredValue = true;
StarboardPost post = StarboardPost.builder().build();
StarboardPost post = Mockito.mock(StarboardPost.class);
when(repository.findByStarboardMessageId(messageId)).thenReturn(post);
testUnit.setStarboardPostIgnored(messageId, ignoredValue);
Assert.assertTrue(post.isIgnored());
verify(post, times(1)).setIgnored(true);
verify(repository, times(1)).save(post);
}
@@ -151,7 +159,7 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testFindByMessageId() {
Long messageId = 5L;
StarboardPost post = StarboardPost.builder().build();
StarboardPost post = Mockito.mock(StarboardPost.class);
when(repository.findByPostMessageId(messageId)).thenReturn(post);
Optional<StarboardPost> postOptional = testUnit.findByMessageId(messageId);
Assert.assertTrue(postOptional.isPresent());
@@ -169,7 +177,7 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testFindByStarboardPostId() {
Long postId = 5L;
StarboardPost post = StarboardPost.builder().build();
StarboardPost post = Mockito.mock(StarboardPost.class);
when(repository.findByStarboardMessageId(postId)).thenReturn(post);
Optional<StarboardPost> postOptional = testUnit.findByStarboardPostId(postId);
Assert.assertTrue(postOptional.isPresent());
@@ -186,12 +194,11 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRetrievePostCount() {
AServer server = MockUtils.getServer();
StarboardPost starboardPost1 = StarboardPost.builder().build();
StarboardPost starboardPost2 = StarboardPost.builder().build();
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2);
when(repository.findByServer_Id(server.getId())).thenReturn(posts);
Integer retrievedPostCount = testUnit.getPostCount(server.getId());
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
Integer retrievedPostCount = testUnit.getPostCount(SERVER_ID);
Assert.assertEquals(posts.size(), retrievedPostCount.intValue());
}
}

50
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/management/StarboardPostReactorManagementServiceBeanTest.java
View File

@@ -1,8 +1,8 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.models.database.StarboardPostReaction;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
@@ -37,40 +37,50 @@ public class StarboardPostReactorManagementServiceBeanTest {
@Captor
private ArgumentCaptor<StarboardPostReaction> reactorCaptor;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AServer server;
@Mock
private AUser aUser;
private static final Long SERVER_ID = 4L;
@Test
public void testAddReactor() {
StarboardPost post = StarboardPost.builder().reactions(new ArrayList<>()).build();
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
testUnit.addReactor(post, userInAServer);
StarboardPost post = Mockito.mock(StarboardPost.class);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
when(aUserInAServer.getServerReference()).thenReturn(server);
testUnit.addReactor(post, aUserInAServer);
verify(repository, times(1)).save(reactorCaptor.capture());
StarboardPostReaction reaction = reactorCaptor.getValue();
Assert.assertEquals(post, reaction.getStarboardPost());
Assert.assertEquals(userInAServer, reaction.getReactor());
Assert.assertEquals(aUserInAServer, reaction.getReactor());
}
@Test
public void testRemoveReactor() {
StarboardPost post = StarboardPost.builder().build();
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
testUnit.removeReactor(post, userInAServer);
verify(repository, times(1)).deleteByReactorAndStarboardPost(userInAServer, post);
StarboardPost post = Mockito.mock(StarboardPost.class);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
when(aUserInAServer.getServerReference()).thenReturn(server);
testUnit.removeReactor(post, aUserInAServer);
verify(repository, times(1)).deleteByReactorAndStarboardPost(aUserInAServer, post);
}
@Test
public void testRemoveReactors() {
StarboardPost post = StarboardPost.builder().reactions(new ArrayList<>()).build();
StarboardPost post = Mockito.mock(StarboardPost.class);
testUnit.removeReactors(post);
verify(repository, times(1)).deleteByStarboardPost(post);
}
@Test
public void testRetrieveStarCount() {
Long serverId = 5L;
Integer stars = 5;
when(repository.getReactionCountByServer(serverId)).thenReturn(stars);
Integer starCount = testUnit.getStarCount(serverId);
when(repository.getReactionCountByServer(SERVER_ID)).thenReturn(stars);
Integer starCount = testUnit.getStarCount(SERVER_ID);
Assert.assertEquals(stars, starCount);
}
@@ -105,11 +115,10 @@ public class StarboardPostReactorManagementServiceBeanTest {
}
private void testTopStarReceiver(int expectedAmount, Integer amountToRetrieve) {
Long serverId = 5L;
StarStatsUser user1 = Mockito.mock(StarStatsUser.class);
StarStatsUser user2 = Mockito.mock(StarStatsUser.class);
setupStarStatsReceiverResult(amountToRetrieve, serverId, user1, user2);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.retrieveTopStarReceiver(serverId, amountToRetrieve);
setupStarStatsReceiverResult(amountToRetrieve, SERVER_ID, user1, user2);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.retrieveTopStarReceiver(SERVER_ID, amountToRetrieve);
Assert.assertEquals(expectedAmount, starStatsUsers.size());
Assert.assertEquals(user1, starStatsUsers.get(0).join());
if(amountToRetrieve > 1) {
@@ -118,11 +127,10 @@ public class StarboardPostReactorManagementServiceBeanTest {
}
private void testTopStarGiver(int expectedAmount, Integer amountToRetrieve) {
Long serverId = 5L;
StarStatsUser user1 = Mockito.mock(StarStatsUser.class);
StarStatsUser user2 = Mockito.mock(StarStatsUser.class);
setupStarStatsGiverResult(amountToRetrieve, serverId, user1, user2);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.retrieveTopStarGiver(serverId, amountToRetrieve);
setupStarStatsGiverResult(amountToRetrieve, SERVER_ID, user1, user2);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.retrieveTopStarGiver(SERVER_ID, amountToRetrieve);
Assert.assertEquals(expectedAmount, starStatsUsers.size());
Assert.assertEquals(user1, starStatsUsers.get(0).join());
if(amountToRetrieve > 1) {

37
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/management/SuggestionManagementServiceBeanTest.java
View File

@@ -2,11 +2,11 @@ package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
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.ChannelManagementService;
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.utility.models.SuggestionState;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.repository.SuggestionRepository;
@@ -44,15 +44,24 @@ public class SuggestionManagementServiceBeanTest {
@Mock
private ServerManagementService serverManagementService;
@Mock
private AServer server;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AUser aUser;
public static final long CHANNEL_ID = 6L;
public static final long SERVER_ID = 6L;
public static final long SUGGESTION_ID = 6L;
@Test
public void testCreateSuggestionViaUser() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
String text = "text";
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
Guild guild = Mockito.mock(Guild.class);
Message message = Mockito.mock(Message.class);
MessageChannel messageChannel = Mockito.mock(MessageChannel.class);
@@ -61,38 +70,38 @@ public class SuggestionManagementServiceBeanTest {
when(message.getGuild()).thenReturn(guild);
when(guild.getId()).thenReturn("8");
long suggestionId = 1L;
Suggestion createdSuggestion = testUnit.createSuggestion(userInAServer, text, message, suggestionId);
Suggestion createdSuggestion = testUnit.createSuggestion(aUserInAServer, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);
Assert.assertEquals(SuggestionState.NEW, createdSuggestion.getState());
Assert.assertEquals(userInAServer.getUserInServerId(), createdSuggestion.getSuggester().getUserInServerId());
Assert.assertEquals(server.getId(), createdSuggestion.getServer().getId());
Assert.assertEquals(aUserInAServer, createdSuggestion.getSuggester());
Assert.assertEquals(server, createdSuggestion.getServer());
}
@Test
public void testCreateSuggestionViaMember() {
Member member = Mockito.mock(Member.class);
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
String text = "text";
Guild guild = Mockito.mock(Guild.class);
Message message = Mockito.mock(Message.class);
MessageChannel messageChannel = Mockito.mock(MessageChannel.class);
when(messageChannel.getIdLong()).thenReturn(CHANNEL_ID);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
when(message.getChannel()).thenReturn(messageChannel);
when(message.getGuild()).thenReturn(guild);
when(guild.getId()).thenReturn("5");
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(aUserInAServer);
long suggestionId = 1L;
Suggestion createdSuggestion = testUnit.createSuggestion(member, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);
Assert.assertEquals(SuggestionState.NEW, createdSuggestion.getState());
Assert.assertEquals(userInAServer.getUserInServerId(), createdSuggestion.getSuggester().getUserInServerId());
Assert.assertEquals(server.getId(), createdSuggestion.getServer().getId());
Assert.assertEquals(aUserInAServer, createdSuggestion.getSuggester());
Assert.assertEquals(server, createdSuggestion.getServer());
}
@Test
public void testGetSuggestion() {
Suggestion foundSuggestion = buildSuggestion();
Suggestion foundSuggestion = createSuggestion();
when(suggestionRepository.findById(new ServerSpecificId(SERVER_ID, SUGGESTION_ID))).thenReturn(Optional.of(foundSuggestion));
Optional<Suggestion> suggestionOptional = testUnit.getSuggestion(SUGGESTION_ID, SERVER_ID);
Assert.assertTrue(suggestionOptional.isPresent());
@@ -109,14 +118,14 @@ public class SuggestionManagementServiceBeanTest {
@Test
public void setSuggestionState() {
Suggestion suggestion = buildSuggestion();
Suggestion suggestion = createSuggestion();
testUnit.setSuggestionState(suggestion, SuggestionState.ACCEPTED);
verify(suggestion, times(1)).setState(SuggestionState.ACCEPTED);
verify(suggestionRepository, times(1)).save(suggestion);
}
private Suggestion buildSuggestion() {
private Suggestion createSuggestion() {
Suggestion foundSuggestion = Mockito.mock(Suggestion.class);
ServerSpecificId suggestionId = Mockito.mock(ServerSpecificId.class);
when(suggestionId.getId()).thenReturn(SUGGESTION_ID);

3
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/validator/StarboardFeatureValidatorServiceTest.java
View File

@@ -4,7 +4,6 @@ import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.FeatureValidatorService;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.config.features.StarboardFeature;
import org.junit.Assert;
import org.junit.Test;
@@ -33,7 +32,7 @@ public class StarboardFeatureValidatorServiceTest {
@Test
public void testStarboardFeatureConfig() {
AServer server = MockUtils.getServer();
AServer server = Mockito.mock(AServer.class);
int levelCount = 4;
SystemConfigProperty config = Mockito.mock(SystemConfigProperty.class);
when(config.getLongValue()).thenReturn((long) levelCount);

10
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/models/database/Reminder.java
View File

@@ -21,25 +21,20 @@ public class Reminder implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Getter
@Column(name = "id")
private Long id;
@Getter
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_in_server_id", nullable = false)
private AUserInAServer remindedUser;
@Getter
@Column(name = "message_id")
private Long messageId;
@Getter
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "channel_id", nullable = false)
private AChannel channel;
@Getter
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "server_id", nullable = false)
private AServer server;
@@ -50,20 +45,15 @@ public class Reminder implements Serializable {
@Column(name = "updated")
private Instant updated;
@Getter
@Column(name = "target_date")
private Instant targetDate;
@Getter
@Column(name = "text")
private String text;
@Getter
@Column(name = "reminded")
private boolean reminded;
@Getter
@Setter
@Column(name = "job_trigger_key")
private String jobTriggerKey;

2
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImplTest.java
View File

@@ -50,7 +50,7 @@ public class AChannelParameterHandlerImplTest extends AbstractParameterHandlerTe
@Test
public void testProperChannelMention() {
UnparsedCommandParameterPiece piece = getPieceWithValue("input");
UnparsedCommandParameterPiece piece = getPiece();
when(textChannelParameterHandler.handle(piece, iterators, TextChannel.class, message)).thenReturn(channel);
when(channelService.getFakeChannelFromTextChannel(channel)).thenReturn(aChannel);
AChannel parsed = (AChannel) testUnit.handle(piece, iterators, TextChannel.class, message);

2
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImplImplTest.java
View File

@@ -51,7 +51,7 @@ public class ARoleParameterHandlerImplImplTest extends AbstractParameterHandlerT
@Test
public void testProperRoleMention() {
UnparsedCommandParameterPiece piece = getPieceWithValue("test");
UnparsedCommandParameterPiece piece = getPiece();
when(roleParameterHandler.handle(piece, iterators, Role.class, message)).thenReturn(role);
when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole);
ARole parsed = (ARole) testUnit.handle(piece, iterators, AEmote.class, message);

11
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AbstractParameterHandlerTest.java
View File

@@ -1,9 +1,18 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
import org.mockito.Mockito;
import static org.mockito.Mockito.when;
public abstract class AbstractParameterHandlerTest {
protected UnparsedCommandParameterPiece getPieceWithValue(String value) {
return UnparsedCommandParameterPiece.builder().value(value).build();
UnparsedCommandParameterPiece mock = Mockito.mock(UnparsedCommandParameterPiece.class);
when(mock.getValue()).thenReturn(value);
return mock;
}
protected UnparsedCommandParameterPiece getPiece() {
return Mockito.mock(UnparsedCommandParameterPiece.class);
}
}

3
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImplImplTest.java
View File

@@ -51,8 +51,7 @@ public class FullRoleParameterHandlerImplImplTest extends AbstractParameterHandl
@Test
public void testProperEmoteMention() {
String input = "test";
UnparsedCommandParameterPiece piece = getPieceWithValue(input);
UnparsedCommandParameterPiece piece = getPiece();
when(roleParameterHandler.handle(piece, iterators, Role.class, message)).thenReturn(role);
when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole);
FullRole parsed = (FullRole) testUnit.handle(piece, iterators, FullRole.class, message);

65
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/CommandServiceBeanTest.java
View File

@@ -11,6 +11,7 @@ import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import static org.mockito.Mockito.when;
@@ -26,22 +27,26 @@ public class CommandServiceBeanTest {
@Test
public void testUsageWithoutParameters() {
executeTest("test", commandWithConfig(getNoParameters()));
CommandConfiguration parameters = getNoParameters();
executeTest("test", commandWithConfig(parameters));
}
@Test
public void testUsageWithOptionalParameter() {
executeTest("test [param1]", commandWithConfig(getOptionalParameterConfig()));
CommandConfiguration parameters = getOptionalParameterConfig();
executeTest("test [param1]", commandWithConfig(parameters));
}
@Test
public void testUsageWithMandatoryParameter() {
executeTest("test <param1>", commandWithConfig(getMandatoryParameterConfig()));
CommandConfiguration getparameters = getMandatoryParameterConfig();
executeTest("test <param1>", commandWithConfig(getparameters));
}
@Test
public void testUsageWithMixedParameters() {
executeTest("test <param1> [param2]", commandWithConfig(getMixedParameterConfig()));
CommandConfiguration parameters = getMixedParameterConfig();
executeTest("test <param1> [param2]", commandWithConfig(parameters));
}
private void executeTest(String expectedUsage, Command commandToExecute) {
@@ -56,40 +61,46 @@ public class CommandServiceBeanTest {
}
private CommandConfiguration getNoParameters() {
return CommandConfiguration
.builder()
.name(COMMAND_NAME)
.build();
CommandConfiguration configuration = Mockito.mock(CommandConfiguration.class);
when(configuration.getName()).thenReturn(COMMAND_NAME);
return configuration;
}
private CommandConfiguration getOptionalParameterConfig() {
return CommandConfiguration
.builder()
.name(COMMAND_NAME)
.parameters(Arrays.asList(getOptionalParameter(true)))
.build();
CommandConfiguration configuration = Mockito.mock(CommandConfiguration.class);
when(configuration.getName()).thenReturn(COMMAND_NAME);
List<Parameter> parameters = Arrays.asList(getParameter(true));
when(configuration.getParameters()).thenReturn(parameters);
return configuration;
}
private CommandConfiguration getMandatoryParameterConfig() {
return CommandConfiguration
.builder()
.name(COMMAND_NAME)
.parameters(Arrays.asList(getOptionalParameter(false)))
.build();
CommandConfiguration configuration = Mockito.mock(CommandConfiguration.class);
when(configuration.getName()).thenReturn(COMMAND_NAME);
List<Parameter> parameters = Arrays.asList(getParameter(false));
when(configuration.getParameters()).thenReturn(parameters);
return configuration;
}
private CommandConfiguration getMixedParameterConfig() {
Parameter param1 = Parameter.builder().name(PARAMETER_1_NAME).type(Object.class).optional(false).build();
Parameter param2 = Parameter.builder().name(PARAMETER_2_NAME).type(Object.class).optional(true).build();
return CommandConfiguration
.builder()
.name(COMMAND_NAME)
.parameters(Arrays.asList(param1, param2))
.build();
Parameter param1 = getParameter(false);
Parameter param2 = Mockito.mock(Parameter.class);
when(param2.getName()).thenReturn(PARAMETER_2_NAME);
when(param2.getType()).thenReturn(Object.class);
when(param2.isOptional()).thenReturn(true);
CommandConfiguration configuration = Mockito.mock(CommandConfiguration.class);
when(configuration.getName()).thenReturn(COMMAND_NAME);
List<Parameter> parameters = Arrays.asList(param1, param2);
when(configuration.getParameters()).thenReturn(parameters);
return configuration;
}
private Parameter getOptionalParameter(boolean b) {
return Parameter.builder().name(PARAMETER_1_NAME).type(Object.class).optional(b).build();
private Parameter getParameter(boolean optional) {
Parameter parameter = Mockito.mock(Parameter.class);
when(parameter.getType()).thenReturn(Object.class);
when(parameter.getName()).thenReturn(PARAMETER_1_NAME);
when(parameter.isOptional()).thenReturn(optional);
return parameter;
}
}

61
abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/test/MockUtils.java
View File

@@ -1,61 +0,0 @@
package dev.sheldan.abstracto.core.test;
import dev.sheldan.abstracto.core.models.database.*;
import net.dv8tion.jda.api.requests.RestAction;
import java.util.function.Consumer;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
public class MockUtils {
private MockUtils() {
}
public static AUserInAServer getUserObject(Long id, AServer server) {
AUser user = AUser.builder().id(id).build();
AUserInAServer createdUser = AUserInAServer.builder().userReference(user).serverReference(server).userInServerId(id).build();
server.getUsers().add(createdUser);
return createdUser;
}
public static AServer getServer(Long id){
return AServer.builder().id(id).build();
}
public static AServer getServer() {
return getServer(2L);
}
public static AChannel getTextChannel(AServer server, Long id) {
return AChannel.builder().id(id).server(server).deleted(false).type(AChannelType.TEXT).build();
}
public static ARole getRole(Long id, AServer server) {
return ARole.builder().server(server).id(id).build();
}
public static void mockQueueDoubleVoidConsumer(RestAction action) {
doAnswer(invocationOnMock -> {
Object consumerObj = invocationOnMock.getArguments()[0];
if(consumerObj instanceof Consumer) {
Consumer<Void> consumer = (Consumer) consumerObj;
consumer.accept(null);
}
return null;
}).when(action).queue(any(Consumer.class), any(Consumer.class));
}
public static void mockQueueVoidConsumer(RestAction action) {
doAnswer(invocationOnMock -> {
Object consumerObj = invocationOnMock.getArguments()[0];
if(consumerObj instanceof Consumer) {
Consumer<Void> consumer = (Consumer) consumerObj;
consumer.accept(null);
}
return null;
}).when(action).queue(any(Consumer.class));
}
}