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

added tests for utility module

Browse Source 
refactored various commands and services
optimized code for message embeds
removed emoteUtils completely and moved to service
removed suggestion validation, because its now done via feature config
fixed regex for discord links
changed template to handle the case in which a member which suggested it originally left the server
added suggestion update exception in cases the message to edit, does not qualify as a suggestion
added check to not allow cross server quoting and added test case
refactored mocking for jda objects
This commit is contained in:
Sheldan
2020-06-07 00:22:42 +02:00
parent a577932c42
commit ac93440546
91 changed files with 3721 additions and 425 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -23,17 +23,17 @@ public abstract class ExperienceRelatedTest {
return experiences;
}
protected AUserExperience getUserExperienceObject(AServer server, int i) {
AUserInAServer userObject = MockUtils.getUserObject((long)i, server);
protected AUserExperience getUserExperienceObject(AServer server, long i) {
AUserInAServer userObject = MockUtils.getUserObject(i, server);
AExperienceLevel level = AExperienceLevel
.builder()
.level(i)
.experienceNeeded((long) i * 100)
.level((int)i)
.experienceNeeded(i * 100)
.build();
return AUserExperience
.builder()
.user(userObject)
.experience((long) i)
.experience(i)
.currentLevel(level)
.build();
}

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

@@ -8,7 +8,6 @@ import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -28,17 +27,14 @@ public class DisableExpForRoleTest {
@Mock
private DisabledExpRoleManagementService disabledExpRoleManagementService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
@@ -53,7 +49,7 @@ public class DisableExpForRoleTest {
private void executeDisableExpForRoleTest(boolean value, int wantedNumberOfInvocations) {
ARole disabledRole = MockUtils.getRole(1L, MockUtils.getServer());
CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(disabledRole));
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(disabledRole));
when(disabledExpRoleManagementService.isExperienceDisabledForRole(disabledRole)).thenReturn(value);
CommandResult result = testUnit.execute(context);
verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).setRoleToBeDisabledForExp(disabledRole);

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

@@ -10,11 +10,11 @@ import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.*;
@@ -33,24 +33,21 @@ public class DisableExpGainTest {
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testDisableExpForMember() {
CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
CommandContext noParameters = CommandTestUtilities.getNoParameters();
AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
Member member = MockUtils.getMockedMember(noParameters.getUserInitiatedContext().getServer(), parameterUser, jda);
Member member = Mockito.mock(Member.class);
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);
CommandResult result = testUnit.execute(context);

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

@@ -8,7 +8,6 @@ import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -28,17 +27,14 @@ public class EnableExpForRoleTest {
@Mock
private DisabledExpRoleManagementService disabledExpRoleManagementService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
@@ -53,7 +49,7 @@ public class EnableExpForRoleTest {
private void executeEnableExpForRoleTest(boolean value, int wantedNumberOfInvocations) {
ARole disabledRole = MockUtils.getRole(1L, MockUtils.getServer());
CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(disabledRole));
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(disabledRole));
when(disabledExpRoleManagementService.isExperienceDisabledForRole(disabledRole)).thenReturn(value);
CommandResult result = testUnit.execute(context);
verify(disabledExpRoleManagementService, times(wantedNumberOfInvocations)).removeRoleToBeDisabledForExp(disabledRole);

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

@@ -10,11 +10,11 @@ import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -33,24 +33,21 @@ public class EnableExpGainTest {
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testEnableExpForMember() {
CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
CommandContext noParameters = CommandTestUtilities.getNoParameters();
AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
Member member = MockUtils.getMockedMember(noParameters.getUserInitiatedContext().getServer(), parameterUser, jda);
Member member = Mockito.mock(Member.class);
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);
CommandResult result = testUnit.execute(context);

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

@@ -6,7 +6,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -26,23 +25,20 @@ public class ExpScaleTest {
@Mock
private ConfigService configService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testSetExpScaleForGuild() {
double newScale = 4.5;
CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(newScale));
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(newScale));
CommandResult result = testUnit.execute(context);
CommandTestUtilities.checkSuccessfulCompletion(result);
verify(configService, times(1)).setDoubleValue(ExpScale.EXP_MULTIPLIER_KEY, context.getGuild().getIdLong(), newScale);

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

@@ -13,7 +13,6 @@ import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -43,22 +42,19 @@ public class LeaderBoardCommandTest {
@Mock
private LeaderBoardModelConverter converter;
@Mock
private JDAImpl jda;
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testLeaderBoardWithNoParameter() {
testLeaderBoardCommand(CommandTestUtilities.getNoParameters(jda), 1);
testLeaderBoardCommand(CommandTestUtilities.getNoParameters(), 1);
}
@Test
public void testLeaderBoardWithPageParameter() {
testLeaderBoardCommand(CommandTestUtilities.getWithParameters(jda, Arrays.asList(5)), 5);
testLeaderBoardCommand(CommandTestUtilities.getWithParameters(Arrays.asList(5)), 5);
}
private void testLeaderBoardCommand(CommandContext context, int expectedPage) {

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

@@ -11,7 +11,6 @@ import dev.sheldan.abstracto.experience.models.templates.DisabledExperienceRoles
import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -38,12 +37,9 @@ public class ListDisabledExperienceRolesTest {
@Mock
private ChannelService channelService;
@Mock
private JDAImpl jda;
@Test
public void testCommandExecutionNoRolesFound() {
CommandContext context = CommandTestUtilities.getNoParameters(jda);
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = context.getUserInitiatedContext().getServer();
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
CommandResult result = testUnit.execute(context);
@@ -55,7 +51,7 @@ public class ListDisabledExperienceRolesTest {
@Test
public void testCommandExecutionRolesFound() {
CommandContext context = CommandTestUtilities.getNoParameters(jda);
CommandContext context = CommandTestUtilities.getNoParameters();
AServer server = context.getUserInitiatedContext().getServer();
ADisabledExpRole disabledExpRole1 = ADisabledExpRole.builder().role(MockUtils.getRole(4L, server)).build();
ADisabledExpRole disabledExpRole2 = ADisabledExpRole.builder().role(MockUtils.getRole(6L, server)).build();

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

@@ -14,7 +14,6 @@ import dev.sheldan.abstracto.experience.service.ExperienceLevelService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -45,14 +44,11 @@ public class RankTest {
@Mock
private ChannelService channelService;
@Mock
private JDAImpl jda;
@Test
public void testRankExecution() {
int currentLevelValue = 50;
long currentExperience = 50L;
CommandContext context = CommandTestUtilities.getNoParameters(jda);
CommandContext context = CommandTestUtilities.getNoParameters();
AExperienceLevel currentLevel = AExperienceLevel.builder().level(currentLevelValue).build();
AUserExperience aUserExperience = AUserExperience.builder().experience(currentExperience).currentLevel(currentLevel).build();
LeaderBoardEntry leaderBoardEntry = LeaderBoardEntry.builder().experience(aUserExperience).build();

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

@@ -10,7 +10,6 @@ import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -33,34 +32,31 @@ public class SetExpRoleTest {
@Mock
private RoleService roleService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = InsufficientParameters.class)
public void testRoleMissing() {
CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(4));
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(4));
testUnit.execute(context);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testLevelProvidedButNotRole() {
CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(4, ""));
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(4, ""));
testUnit.execute(context);
}
@Test
public void setExpRole() {
CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
CommandContext noParameters = CommandTestUtilities.getNoParameters();
ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
Integer levelToSetTo = 4;
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, changedRole));
@@ -72,7 +68,7 @@ public class SetExpRoleTest {
@Test(expected = RoleNotFoundInGuildException.class)
public void setExpRoleNotExistingOnServer() {
CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
CommandContext noParameters = CommandTestUtilities.getNoParameters();
ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
Integer levelToSetTo = 4;
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, changedRole));

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

@@ -6,7 +6,6 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -24,12 +23,9 @@ public class SyncRolesTest {
@Mock
private AUserExperienceService userExperienceService;
@Mock
private JDAImpl jda;
@Test
public void executeCommand() {
CommandContext context = CommandTestUtilities.getNoParameters(jda);
CommandContext context = CommandTestUtilities.getNoParameters();
CommandResult result = testUnit.execute(context);
AServer server = context.getUserInitiatedContext().getServer();
AChannel channel = context.getUserInitiatedContext().getChannel();

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

@@ -8,7 +8,6 @@ import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import net.dv8tion.jda.internal.JDAImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -29,22 +28,19 @@ public class UnSetExpRoleTest {
@Mock
private ExperienceRoleService experienceRoleService;
@Mock
private JDAImpl jda;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit, jda);
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit, jda);
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void setUnSetExpRole() {
CommandContext noParameters = CommandTestUtilities.getNoParameters(jda);
CommandContext noParameters = CommandTestUtilities.getNoParameters();
ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(changedRole));
CommandResult result = testUnit.execute(context);

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

@@ -8,13 +8,14 @@ import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
import dev.sheldan.abstracto.test.MockUtils;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.entities.MemberImpl;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
@@ -31,9 +32,6 @@ public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
@Mock
private BotService botService;
@Mock
private JDAImpl jda;
@Test
public void testFromLeaderBoard() {
AServer server = MockUtils.getServer();
@@ -58,9 +56,13 @@ public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
@Test
public void testFromEntry() {
AServer server = MockUtils.getServer();
AUserExperience experience = getUserExperienceObject(server, 3);
Long userId = 3L;
AUserExperience experience = getUserExperienceObject(server, userId);
LeaderBoardEntry entry = LeaderBoardEntry.builder().experience(experience).rank(1).build();
MemberImpl member = MockUtils.getMockedMember(server, experience.getUser(), jda);
Member member = Mockito.mock(Member.class);
User user = Mockito.mock(User.class);
when(user.getIdLong()).thenReturn(userId);
when(member.getUser()).thenReturn(user);
when(botService.getMemberInServer(server.getId(), experience.getUser().getUserReference().getId())).thenReturn(member);
LeaderBoardEntryModel leaderBoardEntryModel = testUnit.fromLeaderBoardEntry(entry);
Assert.assertEquals(1, leaderBoardEntryModel.getRank().intValue());

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

@@ -6,14 +6,13 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.test.MockUtils;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.entities.MemberImpl;
import net.dv8tion.jda.internal.entities.ReceivedMessage;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
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.*;
@@ -30,16 +29,14 @@ public class ExperienceTrackerListenerTest extends ExperienceRelatedTest {
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private JDAImpl jda;
@Test
public void testExperienceTracking() {
AServer server = AServer.builder().id(3L).build();
AUser user = AUser.builder().id(4L).build();
AUserInAServer userInAServer = AUserInAServer.builder().userReference(user).serverReference(server).build();
MemberImpl member = MockUtils.getMockedMember(server, userInAServer, jda);
ReceivedMessage mockedMessage = MockUtils.buildMockedMessage(1L, "text", member);
Member member = Mockito.mock(Member.class);
Message mockedMessage = Mockito.mock(Message.class);
when(mockedMessage.getMember()).thenReturn(member);
when(userInServerManagementService.loadUser(member)).thenReturn(userInAServer);
testUnit.execute(mockedMessage);
verify(userExperienceService, times(1)).addExperience(userInAServer);

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

@@ -1,20 +1,19 @@
package dev.sheldan.abstracto.experience.listener;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.entities.GuildImpl;
import net.dv8tion.jda.internal.entities.MemberImpl;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.User;
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.*;
@@ -31,16 +30,15 @@ public class JoiningUserRoleListenerTest extends ExperienceRelatedTest {
@Mock
private AUserExperienceService userExperienceService;
@Mock
private JDAImpl jda;
@Test
public void testUserWithExperienceRejoining() {
AServer server = AServer.builder().id(3L).build();
AUser user = AUser.builder().id(1L).build();
AUserInAServer aUserInAServer = AUserInAServer.builder().userInServerId(2L).userReference(user).build();
MemberImpl member = MockUtils.getMockedMember(server, aUserInAServer, jda);
GuildImpl guild = MockUtils.getGuild(server, jda);
Member member = Mockito.mock(Member.class);
User jdaUser = Mockito.mock(User.class);
when(member.getUser()).thenReturn(jdaUser);
when(jdaUser.getIdLong()).thenReturn(user.getId());
Guild guild = Mockito.mock(Guild.class);
AUserExperience experience = AUserExperience.builder().experience(3L).user(aUserInAServer).build();
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
testUnit.execute(member, guild, aUserInAServer);
@@ -49,11 +47,10 @@ public class JoiningUserRoleListenerTest extends ExperienceRelatedTest {
@Test
public void testUserWithOutExperienceRejoining() {
AServer server = AServer.builder().id(3L).build();
AUser user = AUser.builder().id(1L).build();
AUserInAServer aUserInAServer = AUserInAServer.builder().userInServerId(2L).userReference(user).build();
MemberImpl member = MockUtils.getMockedMember(server, aUserInAServer, jda);
GuildImpl guild = MockUtils.getGuild(server, jda);
Member member = Mockito.mock(Member.class);
Guild guild = Mockito.mock(Guild.class);
AUserExperience experience = AUserExperience.builder().experience(3L).user(aUserInAServer).build();
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(null);
testUnit.execute(member, guild, aUserInAServer);

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

@@ -21,15 +21,12 @@ import dev.sheldan.abstracto.experience.service.management.UserExperienceManagem
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.MockUtils;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.entities.*;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
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 static org.mockito.Mockito.*;
@@ -74,9 +71,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
@Mock
private BotService botService;
@Mock
private JDAImpl jda;
@Mock
private RunTimeExperienceService runTimeExperienceService;
@@ -159,7 +153,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
levels.add(AExperienceLevel.builder().level(4).experienceNeeded(400L).build());
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
AExperienceRole previousExperienceRole = experienceRoles.get(3);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 401L, 3, previousExperienceRole, false);
@@ -183,7 +177,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 101L, 1, null, false);
@@ -202,7 +196,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, null, false);
@@ -221,7 +215,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), false);
@@ -243,7 +237,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MockUtils.getMockedMember(serverToUse, userToUse, jda);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), true);
testUnit.handleExperienceGain(servers);
@@ -262,7 +255,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), false);
when(botService.getMemberInServer(userToUse)).thenReturn(jdaMember);
when(roleService.hasAnyOfTheRoles(eq(jdaMember), anyList())).thenReturn(true);
@@ -282,7 +275,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
mockSimpleServer(levels, experienceRoles, serverToUse);
AUserInAServer userToUse = serverToUse.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 101L, 1, experienceRoles.get(1), false);
when(experienceRoleService.calculateRole(newUserExperience, experienceRoles)).thenReturn(experienceRoles.get(1));
@@ -311,7 +304,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AExperienceRole> experienceRoles = getExperienceRoles(levels, aServer);
mockSimpleServer(levels, experienceRoles, aServer);
AUserInAServer userToUse = aServer.getUsers().get(0);
MemberImpl jdaMember = MockUtils.getMockedMember(aServer, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(aServer, userToUse.getUserReference())).thenReturn(jdaMember);
AExperienceRole role = experienceRoles.get(experienceRoleIndices.get(i));
AUserExperience newUserExperience = mockServerWithSingleUser(levels, aServer, experienceValues, level, role, false);
@@ -450,9 +443,9 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AUserExperience> experiences = Arrays.asList(experience, experience2);
List<AUserInAServer> users = experiences.stream().map(AUserExperience::getUser).collect(Collectors.toList());
MemberImpl firstMember = MockUtils.getMockedMember(server, users.get(0), jda);
Member firstMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(firstMember);
MemberImpl secondMember = MockUtils.getMockedMember(server, users.get(1), jda);
Member secondMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(server, users.get(1).getUserReference())).thenReturn(secondMember);
experience.setCurrentExperienceRole(firstPreviousRole);
experience2.setCurrentExperienceRole(secondPreviousRole);
@@ -547,7 +540,8 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
MessageToSend statusMessage = MessageToSend.builder().message("text").build();
when(templateService.renderEmbedTemplate(eq("user_sync_status_message"), any(UserSyncStatusModel.class))).thenReturn(statusMessage);
long messageId = 5L;
ReceivedMessage statusMessageJDA = MockUtils.buildMockedMessage(messageId, "text", null);
Message statusMessageJDA = Mockito.mock(Message.class);
when(statusMessageJDA.getIdLong()).thenReturn(messageId);
when(messageService.createStatusMessage(statusMessage, channel)).thenReturn(CompletableFuture.completedFuture(statusMessageJDA));
testUnit.syncUserRolesWithFeedback(server, channel);
verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
@@ -559,7 +553,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
List<AUserExperience> experiences = Arrays.asList(experience);
List<AUserInAServer> users = experiences.stream().map(AUserExperience::getUser).collect(Collectors.toList());
MemberImpl firstMember = MockUtils.getMockedMember(server, users.get(0), jda);
Member firstMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(firstMember);
experience.setCurrentExperienceRole(previousRole);
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
@@ -605,7 +599,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
private AExperienceRole testRoleRelatedScenario(boolean shouldHaveRole, List<AExperienceLevel> levels, List<AServer> servers, AServer serverToUse, List<AExperienceRole> experienceRoles, AUserInAServer userToUse, AExperienceRole previousExperienceRole) {
mockSimpleServer(levels, experienceRoles, serverToUse);
MemberImpl jdaMember = MockUtils.getMockedMember(serverToUse, userToUse, jda);
Member jdaMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 301L, 1, previousExperienceRole, false);

8
abstracto-application/abstracto-modules/utility/utility-impl/pom.xml
View File

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

4
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/ShowAvatar.java
View File

@@ -22,16 +22,18 @@ import java.util.List;
@Component
public class ShowAvatar extends AbstractConditionableCommand {
public static final String SHOW_AVATAR_RESPONSE_TEMPLATE = "showAvatar_response";
@Autowired
private ChannelService channelService;
@Override
public CommandResult execute(CommandContext commandContext) {
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
Member memberToShow = parameters.size() == 1 ? (Member) parameters.get(0) : commandContext.getUserInitiatedContext().getMember();
ShowAvatarModel model = (ShowAvatarModel) ContextConverter.fromCommandContext(commandContext, ShowAvatarModel.class);
model.setMemberInfo(memberToShow);
channelService.sendEmbedTemplateInChannel("showAvatar_response", model, commandContext.getChannel());
channelService.sendEmbedTemplateInChannel(SHOW_AVATAR_RESPONSE_TEMPLATE, model, commandContext.getChannel());
return CommandResult.fromSuccess();
}

18
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/ShowEmote.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.ShowEmoteLog;
import net.dv8tion.jda.api.entities.Emote;
@@ -20,23 +20,19 @@ import java.util.List;
@Component
public class ShowEmote extends AbstractConditionableCommand {
private static final String SHOW_EMOTE_RESPONSE_TEMPLATE = "showEmote_response";
public static final String SHOW_EMOTE_RESPONSE_TEMPLATE = "showEmote_response";
@Autowired
private TemplateService templateService;
private ChannelService channelService;
@Override
public CommandResult execute(CommandContext commandContext) {
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
Object emoteParameter = parameters.get(0);
if(!(emoteParameter instanceof Emote)) {
return CommandResult.fromError(templateService.renderTemplate("no_custom_emote_found", new Object()));
}
Emote emote = (Emote) emoteParameter;
Emote emoteParameter = (Emote) parameters.get(0);
ShowEmoteLog emoteLog = (ShowEmoteLog) ContextConverter.fromCommandContext(commandContext, ShowEmoteLog.class);
emoteLog.setEmote(emote);
String message = templateService.renderTemplate(SHOW_EMOTE_RESPONSE_TEMPLATE, emoteLog);
commandContext.getChannel().sendMessage(message).queue();
emoteLog.setEmote(emoteParameter);
channelService.sendEmbedTemplateInChannel(SHOW_EMOTE_RESPONSE_TEMPLATE, emoteLog, commandContext.getChannel());
return CommandResult.fromSuccess();
}

8
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/StarStats.java
View File

@@ -8,9 +8,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsModel;
import dev.sheldan.abstracto.utility.service.StarboardService;
@@ -28,17 +26,13 @@ public class StarStats extends AbstractConditionableCommand {
@Autowired
private StarboardService starboardService;
@Autowired
private TemplateService templateService;
@Autowired
private ChannelService channelService;
@Override
public CommandResult execute(CommandContext commandContext) {
StarStatsModel result = starboardService.retrieveStarStats(commandContext.getGuild().getIdLong());
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARSTATS_RESPONSE_TEMPLATE, result);
channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
channelService.sendEmbedTemplateInChannel(STARSTATS_RESPONSE_TEMPLATE, result, commandContext.getChannel());
return CommandResult.fromSuccess();
}

3
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/UserInfo.java
View File

@@ -35,8 +35,9 @@ public class UserInfo extends AbstractConditionableCommand {
@Override
public CommandResult execute(CommandContext commandContext) {
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
Member memberToShow = parameters.size() == 1 ? (Member) parameters.get(0) : commandContext.getUserInitiatedContext().getMember();
Member memberToShow = parameters.size() == 1 ? (Member) parameters.get(0) : commandContext.getAuthor();
UserInfoModel model = (UserInfoModel) ContextConverter.fromCommandContext(commandContext, UserInfoModel.class);
if(!memberToShow.hasTimeJoined()) {
botService.forceReloadMember(memberToShow).thenAccept(member -> {

13
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/remind/Remind.java
View File

@@ -8,7 +8,9 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.ReminderModel;
import dev.sheldan.abstracto.utility.service.ReminderService;
import net.dv8tion.jda.api.entities.MessageEmbed;
@@ -22,11 +24,17 @@ import java.util.List;
@Component
public class Remind extends AbstractConditionableCommand {
public static final String REMINDER_EMBED_KEY = "remind_response";
@Autowired
private ReminderService remindService;
@Autowired
private ChannelService channelService;
@Override
public CommandResult execute(CommandContext commandContext) {
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
Duration remindTime = (Duration) parameters.get(0);
String text = (String) parameters.get(1);
@@ -34,7 +42,10 @@ public class Remind extends AbstractConditionableCommand {
ReminderModel remindModel = (ReminderModel) ContextConverter.fromCommandContext(commandContext, ReminderModel.class);
remindModel.setMessage(commandContext.getMessage());
remindModel.setRemindText(text);
remindService.createReminderInForUser(aUserInAServer, text, remindTime, remindModel);
Reminder createdReminder = remindService.createReminderInForUser(aUserInAServer, text, remindTime, commandContext.getMessage());
remindModel.setReminder(createdReminder);
channelService.sendEmbedTemplateInChannel(REMINDER_EMBED_KEY, remindModel, commandContext.getChannel());
return CommandResult.fromSuccess();
}

8
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/remind/Reminders.java
View File

@@ -9,8 +9,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.RemindersModel;
@@ -23,22 +21,20 @@ import java.util.List;
@Component
public class Reminders extends AbstractConditionableCommand {
public static final String REMINDERS_RESPONSE_TEMPLATE = "reminders_response";
@Autowired
private ReminderManagementService reminderManagementService;
@Autowired
private ChannelService channelService;
@Autowired
private TemplateService templateService;
@Override
public CommandResult execute(CommandContext commandContext) {
List<Reminder> activeReminders = reminderManagementService.getActiveRemindersForUser(commandContext.getUserInitiatedContext().getAUserInAServer());
RemindersModel model = (RemindersModel) ContextConverter.fromCommandContext(commandContext, RemindersModel.class);
model.setReminders(activeReminders);
MessageToSend messageToSend = templateService.renderEmbedTemplate("reminders_response", model);
channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
channelService.sendEmbedTemplateInChannel(REMINDERS_RESPONSE_TEMPLATE, model, commandContext.getChannel());
return CommandResult.fromSuccess();
}

1
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/remind/UnRemind.java
View File

@@ -26,6 +26,7 @@ public class UnRemind extends AbstractConditionableCommand {
@Override
public CommandResult execute(CommandContext commandContext) {
checkParameters(commandContext);
Long reminderId = (Long) commandContext.getParameters().getParameters().get(0);
reminderService.unRemind(reminderId, commandContext.getUserInitiatedContext().getAUserInAServer());
return CommandResult.fromSuccess();

2
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/suggest/Accept.java
View File

@@ -24,7 +24,7 @@ public class Accept extends AbstractConditionableCommand {
@Override
public CommandResult execute(CommandContext commandContext) {
suggestionService.validateSetup(commandContext.getGuild().getIdLong());
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
Long suggestionId = (Long) parameters.get(0);
String text = parameters.size() == 2 ? (String) parameters.get(1) : "";

2
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/suggest/Reject.java
View File

@@ -24,7 +24,7 @@ public class Reject extends AbstractConditionableCommand {
@Override
public CommandResult execute(CommandContext commandContext) {
suggestionService.validateSetup(commandContext.getGuild().getIdLong());
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
Long suggestionId = (Long) parameters.get(0);
String text = parameters.size() == 2 ? (String) parameters.get(1) : "";

2
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/suggest/Suggest.java
View File

@@ -24,7 +24,7 @@ public class Suggest extends AbstractConditionableCommand {
@Override
public CommandResult execute(CommandContext commandContext) {
suggestionService.validateSetup(commandContext.getGuild().getIdLong());
checkParameters(commandContext);
List<Object> parameters = commandContext.getParameters().getParameters();
String text = (String) parameters.get(0);
SuggestionLog suggestLogModel = (SuggestionLog) ContextConverter.fromCommandContext(commandContext, SuggestionLog.class);

6
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/config/StarboardConfigListener.java
View File

@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.utility.config;
import dev.sheldan.abstracto.core.listener.ServerConfigListener;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
import dev.sheldan.abstracto.utility.service.StarboardServiceBean;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -20,9 +21,10 @@ public class StarboardConfigListener implements ServerConfigListener {
@Override
public void updateServerConfig(AServer server) {
log.info("Creating starboard config for server {}", server.getId());
for (int i = 0; i < starboardConfig.getLvl().size(); i++) {
int levels = starboardConfig.getLvl().size();
for (int i = 0; i < levels; i++) {
Integer value = starboardConfig.getLvl().get(i);
configManagementService.createIfNotExists(server.getId(), "starLvl" + ( i + 1 ), Long.valueOf(value));
configManagementService.createIfNotExists(server.getId(), StarboardServiceBean.STAR_LVL_CONFIG_PREFIX + ( i + 1 ), Long.valueOf(value));
}
}
}

6
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/config/StarboardDefaultConfigListener.java
View File

@@ -1,6 +1,7 @@
package dev.sheldan.abstracto.utility.config;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.utility.service.StarboardServiceBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
@@ -19,9 +20,10 @@ public class StarboardDefaultConfigListener {
@EventListener
@Transactional
public void handleContextRefreshEvent(ContextRefreshedEvent ctxStartEvt) {
for (int i = 0; i < starboardConfig.getLvl().size(); i++) {
int levels = starboardConfig.getLvl().size();
for (int i = 0; i < levels; i++) {
Integer value = starboardConfig.getLvl().get(i);
defaultConfigManagementService.createDefaultConfig("starLvl" + ( i + 1 ), Long.valueOf(value));
defaultConfigManagementService.createDefaultConfig(StarboardServiceBean.STAR_LVL_CONFIG_PREFIX + ( i + 1 ), Long.valueOf(value));
}
}
}

11
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/listener/embed/MessageEmbedListener.java
View File

@@ -13,6 +13,7 @@ import net.dv8tion.jda.api.entities.Message;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.function.Consumer;
@@ -37,9 +38,13 @@ public class MessageEmbedListener implements MessageReceivedListener {
public void execute(Message message) {
String messageRaw = message.getContentRaw();
List<MessageEmbedLink> links = messageEmbedService.getLinksInMessage(messageRaw);
for (MessageEmbedLink messageEmbedLink : links) {
messageRaw = messageRaw.replace(messageEmbedLink.getWholeUrl(), "");
if(!links.isEmpty()) {
Long userEmbeddingUserInServerId = userInServerManagementService.loadUser(message.getMember()).getUserInServerId();
for (MessageEmbedLink messageEmbedLink : links) {
if(!messageEmbedLink.getServerId().equals(message.getGuild().getIdLong())) {
continue;
}
messageRaw = messageRaw.replace(messageEmbedLink.getWholeUrl(), "");
Consumer<CachedMessage> cachedMessageConsumer = cachedMessage ->self.loadUserAndEmbed(message, userEmbeddingUserInServerId, cachedMessage);
messageCache.getMessageFromCache(messageEmbedLink.getServerId(), messageEmbedLink.getChannelId(), messageEmbedLink.getMessageId()).thenAccept(cachedMessageConsumer)
.exceptionally(throwable -> {
@@ -47,11 +52,13 @@ public class MessageEmbedListener implements MessageReceivedListener {
return null;
});
}
}
if(StringUtils.isBlank(messageRaw) && !links.isEmpty()) {
message.delete().queue();
}
}
@Transactional
public void loadUserAndEmbed(Message message, Long cause, CachedMessage cachedMessage) {
messageEmbedService.embedLink(cachedMessage, message.getTextChannel(), cause , message);
}

5
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/listener/embed/MessageEmbedRemovalReactionListener.java
View File

@@ -9,7 +9,6 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.utils.EmoteUtils;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.database.EmbeddedMessage;
import dev.sheldan.abstracto.utility.service.management.MessageEmbedPostManagementService;
@@ -47,7 +46,7 @@ public class MessageEmbedRemovalReactionListener implements ReactedAddedListener
MessageReaction.ReactionEmote reactionEmote = reaction.getReactionEmote();
Optional<Emote> emoteInGuild = botService.getEmote(guildId, aEmote);
log.trace("Removing embed in message {} in channel {} in server {} because of a user reaction.", message.getMessageId(), message.getChannelId(), message.getServerId());
if(EmoteUtils.isReactionEmoteAEmote(reactionEmote, aEmote, emoteInGuild.orElse(null))) {
if(emoteService.isReactionEmoteAEmote(reactionEmote, aEmote, emoteInGuild.orElse(null))) {
Optional<EmbeddedMessage> embeddedMessageOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(message.getMessageId());
if(embeddedMessageOptional.isPresent()) {
EmbeddedMessage embeddedMessage = embeddedMessageOptional.get();
@@ -57,7 +56,7 @@ public class MessageEmbedRemovalReactionListener implements ReactedAddedListener
) {
messageService.deleteMessageInChannelInServer(message.getServerId(), message.getChannelId(), message.getMessageId()).thenAccept(aVoid ->{
Optional<EmbeddedMessage> innerOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(message.getMessageId());
innerOptional.ifPresent(value -> messageEmbedPostManagementService.deleteEmbeddedMessageTransactional(value));
innerOptional.ifPresent(value -> messageEmbedPostManagementService.deleteEmbeddedMessage(value));
});
}

17
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/listener/starboard/StarboardListener.java
View File

@@ -12,7 +12,6 @@ import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.EmoteUtils;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.service.StarboardService;
@@ -26,6 +25,7 @@ import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
@@ -34,6 +34,7 @@ import java.util.stream.Collectors;
public class StarboardListener implements ReactedAddedListener, ReactedRemovedListener, ReactionClearedListener {
public static final String STAR_EMOTE = "star";
public static final String FIRST_LEVEL_THRESHOLD_KEY = "starLvl1";
@Autowired
private BotService botService;
@@ -66,9 +67,9 @@ public class StarboardListener implements ReactedAddedListener, ReactedRemovedLi
AEmote aEmote = emoteService.getEmoteOrFakeEmote(STAR_EMOTE, guildId);
MessageReaction.ReactionEmote reactionEmote = addedReaction.getReactionEmote();
Optional<Emote> emoteInGuild = botService.getEmote(guildId, aEmote);
if(EmoteUtils.isReactionEmoteAEmote(reactionEmote, aEmote, emoteInGuild.orElse(null))) {
if(emoteService.isReactionEmoteAEmote(reactionEmote, aEmote, emoteInGuild.orElse(null))) {
log.trace("User {} in server {} reacted with star to put a message {} on starboard.", userAdding.getUserReference().getId(), userAdding.getServerReference().getId(), message.getMessageId());
Optional<CachedReaction> reactionOptional = EmoteUtils.getReactionFromMessageByEmote(message, aEmote);
Optional<CachedReaction> reactionOptional = emoteService.getReactionFromMessageByEmote(message, aEmote);
handleStarboardPostChange(message, reactionOptional.orElse(null), userAdding, true);
}
}
@@ -78,7 +79,7 @@ public class StarboardListener implements ReactedAddedListener, ReactedRemovedLi
if(reaction != null) {
AUserInAServer author = userInServerManagementService.loadUser(message.getServerId(), message.getAuthorId());
List<AUserInAServer> userExceptAuthor = getUsersExcept(reaction.getUserInServersIds(), author);
Long starMinimum = getFromConfig("starLvl1", message.getServerId());
Long starMinimum = getFromConfig(FIRST_LEVEL_THRESHOLD_KEY, message.getServerId());
if (userExceptAuthor.size() >= starMinimum) {
log.info("Post reached starboard minimum. Message {} in channel {} in server {} will be starred/updated.",
message.getMessageId(), message.getChannelId(), message.getServerId());
@@ -129,10 +130,10 @@ public class StarboardListener implements ReactedAddedListener, ReactedRemovedLi
AEmote aEmote = emoteService.getEmoteOrFakeEmote(STAR_EMOTE, guildId);
MessageReaction.ReactionEmote reactionEmote = removedReaction.getReactionEmote();
Optional<Emote> emoteInGuild = botService.getEmote(guildId, aEmote);
if(EmoteUtils.isReactionEmoteAEmote(reactionEmote, aEmote, emoteInGuild.orElse(null))) {
if(emoteService.isReactionEmoteAEmote(reactionEmote, aEmote, emoteInGuild.orElse(null))) {
log.trace("User {} in server {} removed star reaction from message {} on starboard.",
userRemoving.getUserReference().getId(), userRemoving.getServerReference().getId(), message.getMessageId());
Optional<CachedReaction> reactionOptional = EmoteUtils.getReactionFromMessageByEmote(message, aEmote);
Optional<CachedReaction> reactionOptional = emoteService.getReactionFromMessageByEmote(message, aEmote);
handleStarboardPostChange(message, reactionOptional.orElse(null), userRemoving, false);
}
}
@@ -144,8 +145,8 @@ public class StarboardListener implements ReactedAddedListener, ReactedRemovedLi
private List<AUserInAServer> getUsersExcept(List<Long> users, AUserInAServer author) {
return users.stream().filter(user -> !user.equals(author.getUserInServerId())).map(aLong -> {
Optional<AUserInAServer> aUserInAServer = userInServerManagementService.loadUser(aLong);
return aUserInAServer.get();
}).collect(Collectors.toList());
return aUserInAServer.orElse(null);
}).filter(Objects::nonNull).collect(Collectors.toList());
}
@Override

3
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/repository/StarboardPostRepository.java
View File

@@ -17,6 +17,9 @@ public interface StarboardPostRepository extends JpaRepository<StarboardPost, Lo
@QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
StarboardPost findByStarboardMessageId(Long messageId);
@QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
boolean existsByStarboardMessageId(Long messageId);
@QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
List<StarboardPost> findByStarboardChannelServerId(Long serverId);

11
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/MessageEmbedServiceBean.java
View File

@@ -37,7 +37,7 @@ import java.util.regex.Pattern;
@Slf4j
public class MessageEmbedServiceBean implements MessageEmbedService {
private Pattern messageRegex = Pattern.compile("(?<whole>https://discordapp.com/channels/(?<server>\\d+)/(?<channel>\\d+)/(?<message>\\d+)(?:.*?))+");
private Pattern messageRegex = Pattern.compile("(?<whole>https://discord(?:app)?.com/channels/(?<server>\\d+)/(?<channel>\\d+)/(?<message>\\d+)(?:.*?))+");
public static final String MESSAGE_EMBED_TEMPLATE = "message_embed";
public static final String REMOVAL_EMOTE = "removeEmbed";
@@ -138,9 +138,9 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
cachedMessage.getMessageId(), cachedMessage.getChannelId(), cachedMessage.getServerId(), throwable);
return null;
});
} else {
log.warn("User {} which was not found in database wanted to embed link in message {}.", userEmbeddingUserInServerId, embeddingMessage.getJumpUrl());
}
}
private MessageEmbeddedModel buildTemplateParameter(Message message, CachedMessage embeddedMessage) {
@@ -149,10 +149,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
AUserInAServer user = userInServerManagementService.loadUser(message.getMember());
Member author = botService.getMemberInServer(embeddedMessage.getServerId(), embeddedMessage.getAuthorId());
Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServer(embeddedMessage.getServerId(), embeddedMessage.getChannelId());
TextChannel sourceChannel = null;
if(textChannelFromServer.isPresent()) {
sourceChannel = textChannelFromServer.get();
}
TextChannel sourceChannel = textChannelFromServer.orElse(null);
AChannel channel = channelOpt.orElseThrow(() -> new ChannelNotFoundException(message.getChannel().getIdLong(), server.getId()));
return MessageEmbeddedModel
.builder()

24
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/RemindServiceBean.java
View File

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
@@ -14,11 +15,11 @@ import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.exception.ReminderNotFoundException;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.ExecutedReminderModel;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.ReminderModel;
import dev.sheldan.abstracto.utility.service.management.ReminderManagementService;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.quartz.JobDataMap;
import org.springframework.beans.factory.annotation.Autowired;
@@ -35,7 +36,6 @@ import java.util.concurrent.*;
@Slf4j
public class RemindServiceBean implements ReminderService {
public static final String REMINDER_EMBED_KEY = "remind_response";
@Autowired
private ReminderManagementService reminderManagementService;
@@ -58,8 +58,8 @@ public class RemindServiceBean implements ReminderService {
private ChannelService channelService;
@Override
public void createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, ReminderModel reminderModel) {
AChannel channel = reminderModel.getChannel();
public Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Message message) {
AChannel channel = channelManagementService.loadChannel(message.getChannel().getIdLong()).orElseThrow(() -> new ChannelNotFoundException(message.getChannel().getIdLong(), message.getGuild().getIdLong()));
AServerAChannelAUser aServerAChannelAUser = AServerAChannelAUser
.builder()
.user(user.getUserReference())
@@ -68,15 +68,13 @@ public class RemindServiceBean implements ReminderService {
.channel(channel)
.build();
Instant remindAt = Instant.now().plusNanos(remindIn.toNanos());
Reminder reminder = reminderManagementService.createReminder(aServerAChannelAUser, remindText, remindAt, reminderModel.getMessage().getIdLong());
reminderModel.setReminder(reminder);
MessageToSend message = templateService.renderEmbedTemplate(REMINDER_EMBED_KEY, reminderModel);
channelService.sendMessageToSendToAChannel(message, reminderModel.getChannel());
Reminder reminder = reminderManagementService.createReminder(aServerAChannelAUser, remindText, remindAt, message.getIdLong());
log.info("Creating reminder for user {} in guild {} due at {}.",
user.getUserReference().getId(), user.getServerReference().getId(), remindAt);
if(remindIn.getSeconds() < 60) {
log.trace("Directly scheduling the reminder, because it was below the threshold.");
// TODO make a bean out of this
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.schedule(() -> {
try {
@@ -93,6 +91,7 @@ public class RemindServiceBean implements ReminderService {
reminder.setJobTriggerKey(triggerKey);
reminderManagementService.saveReminder(reminder);
}
return reminder;
}
@Override
@@ -112,7 +111,7 @@ public class RemindServiceBean implements ReminderService {
if(channelToAnswerIn.isPresent()) {
AUser userReference = reminderToRemindFor.getRemindedUser().getUserReference();
Member memberInServer = botService.getMemberInServer(server.getId(), userReference.getId());
log.trace("Reminding user {}", memberInServer.getUser().getIdLong());
log.trace("Reminding user {}", userReference.getId());
ExecutedReminderModel build = ExecutedReminderModel
.builder()
.reminder(reminderToRemindFor)
@@ -132,15 +131,10 @@ public class RemindServiceBean implements ReminderService {
@Override
public void unRemind(Long reminderId, AUserInAServer aUserInAServer) {
Reminder reminder = reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, reminderId);
if(reminder != null) {
Reminder reminder = reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, reminderId).orElseThrow(() -> new ReminderNotFoundException(reminderId));
reminder.setReminded(true);
if(reminder.getJobTriggerKey() != null) {
schedulerService.stopTrigger(reminder.getJobTriggerKey());
}
reminderManagementService.saveReminder(reminder);
} else {
throw new ReminderNotFoundException(reminderId);
}
}
}

29
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/StarboardServiceBean.java
View File

@@ -42,6 +42,7 @@ import java.util.stream.Collectors;
public class StarboardServiceBean implements StarboardService {
public static final String STARBOARD_POST_TEMPLATE = "starboard_post";
public static final String STAR_LVL_CONFIG_PREFIX = "starLvl";
@Autowired
private BotService botService;
@@ -102,7 +103,6 @@ public class StarboardServiceBean implements StarboardService {
@Transactional
public void persistPost(CachedMessage message, List<Long> userExceptAuthorIds, List<CompletableFuture<Message>> completableFutures, Long starboardChannelId, Long starredUserId, Long userReactingId) {
AUserInAServer innerStarredUser = userInServerManagementService.loadUser(starredUserId).orElseThrow(() -> new UserInServerNotFoundException(starredUserId));
AUserInAServer innerUserReacting = userInServerManagementService.loadUser(userReactingId).orElseThrow(() -> new UserInServerNotFoundException(userReactingId));
try {
AChannel starboardChannel = channelManagementService.loadChannel(starboardChannelId).orElseThrow(() -> new ChannelNotFoundException(starboardChannelId, message.getServerId()));
Message message1 = completableFutures.get(0).get();
@@ -112,7 +112,10 @@ public class StarboardServiceBean implements StarboardService {
.channel(starboardChannel)
.server(starboardChannel.getServer())
.build();
StarboardPost starboardPost = starboardPostManagementService.createStarboardPost(message, innerStarredUser, innerUserReacting, aServerAChannelMessage);
StarboardPost starboardPost = starboardPostManagementService.createStarboardPost(message, innerStarredUser, aServerAChannelMessage);
if(userExceptAuthorIds.isEmpty()) {
log.warn("There are no user ids except the author for the reactions in post {} in guild {} for message {} in channel {}.", starboardPost.getId(), message.getChannelId(), message.getMessageId(), message.getChannelId());
}
userExceptAuthorIds.forEach(aLong -> {
AUserInAServer user = userInServerManagementService.loadUser(aLong).orElseThrow(() -> new UserInServerNotFoundException(aLong));
starboardPostReactorManagementService.addReactor(starboardPost, user);
@@ -149,9 +152,7 @@ public class StarboardServiceBean implements StarboardService {
public void updateStarboardPost(StarboardPost post, CachedMessage message, List<AUserInAServer> userExceptAuthor) {
StarboardPostModel starboardPostModel = buildStarboardPostModel(message, userExceptAuthor.size());
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel);
List<CompletableFuture<Message>> futures = new ArrayList<>();
futures.add(new CompletableFuture<>());
postTargetService.editOrCreatedInPostTarget(post.getStarboardMessageId(), messageToSend, StarboardPostTarget.STARBOARD, message.getServerId(), futures);
List<CompletableFuture<Message>> futures = postTargetService.editOrCreatedInPostTarget(post.getStarboardMessageId(), messageToSend, StarboardPostTarget.STARBOARD, message.getServerId());
Long starboardPostId = post.getId();
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
try {
@@ -180,7 +181,7 @@ public class StarboardServiceBean implements StarboardService {
int count = 3;
List<StarboardPost> starboardPosts = starboardPostManagementService.retrieveTopPosts(serverId, count);
List<StarStatsUser> topStarGivers = starboardPostReactorManagementService.retrieveTopStarGiver(serverId, count);
List<StarStatsPost> starStatsPosts = starboardPosts.stream().map(StarStatsPost::fromStarboardPost).collect(Collectors.toList());
List<StarStatsPost> starStatsPosts = starboardPosts.stream().map(this::fromStarboardPost).collect(Collectors.toList());
List<StarStatsUser> topStarReceiver = starboardPostReactorManagementService.retrieveTopStarReceiver(serverId, count);
Integer postCount = starboardPostManagementService.getPostCount(serverId);
Integer reactionCount = starboardPostReactorManagementService.getStarCount(serverId);
@@ -200,6 +201,17 @@ public class StarboardServiceBean implements StarboardService {
.build();
}
public StarStatsPost fromStarboardPost(StarboardPost starboardPost) {
AChannel channel = starboardPost.getStarboardChannel();
return StarStatsPost
.builder()
.serverId(channel.getServer().getId())
.channelId(channel.getId())
.messageId(starboardPost.getPostMessageId())
.starCount(starboardPost.getReactions().size())
.build();
}
private String getStarboardRankingEmote(Long serverId, Integer position) {
return emoteService.getUsableEmoteOrDefault(serverId, buildBadgeName(position));
}
@@ -209,8 +221,9 @@ public class StarboardServiceBean implements StarboardService {
}
private String getAppropriateEmote(Long serverId, Integer starCount) {
for(int i = starboardConfig.getLvl().size(); i > 0; i--) {
Long starMinimum = configService.getLongValue("starLvl" + i, serverId);
int maxLevels = starboardConfig.getLvl().size();
for(int i = maxLevels; i > 0; i--) {
Long starMinimum = configService.getLongValue(STAR_LVL_CONFIG_PREFIX + i, serverId);
if(starCount >= starMinimum) {
return emoteService.getUsableEmoteOrDefault(serverId, "star" + i);
}

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

@@ -1,6 +1,7 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.MessageService;
@@ -9,12 +10,12 @@ import dev.sheldan.abstracto.core.utils.MessageUtils;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.config.posttargets.SuggestionPostTarget;
import dev.sheldan.abstracto.utility.exception.SuggestionNotFoundException;
import dev.sheldan.abstracto.utility.exception.SuggestionUpdateException;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.SuggestionState;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.management.SuggestionManagementService;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.entities.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -31,8 +32,8 @@ import java.util.concurrent.ExecutionException;
public class SuggestionServiceBean implements SuggestionService {
public static final String SUGGESTION_LOG_TEMPLATE = "suggest_log";
private static final String SUGGESTION_YES_EMOTE = "suggestionYes";
private static final String SUGGESTION_NO_EMOTE = "suggestionNo";
public static final String SUGGESTION_YES_EMOTE = "suggestionYes";
public static final String SUGGESTION_NO_EMOTE = "suggestionNo";
@Autowired
private SuggestionManagementService suggestionManagementService;
@@ -49,6 +50,9 @@ public class SuggestionServiceBean implements SuggestionService {
@Autowired
private MessageService messageService;
@Autowired
private UserInServerManagementService userInServerManagementService;
@Autowired
private SuggestionServiceBean self;
@@ -56,13 +60,11 @@ public class SuggestionServiceBean implements SuggestionService {
public void createSuggestion(Member member, String text, SuggestionLog suggestionLog) {
Suggestion suggestion = suggestionManagementService.createSuggestion(member, text);
suggestionLog.setSuggestion(suggestion);
suggestionLog.setSuggesterUser(suggestion.getSuggester());
suggestionLog.setText(text);
Long suggestionId = suggestion.getId();
MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_LOG_TEMPLATE, suggestionLog);
long guildId = member.getGuild().getIdLong();
JDA instance = botService.getInstance();
Guild guildById = instance.getGuildById(guildId);
if(guildById != null) {
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, guildId);
CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
Suggestion innerSuggestion = suggestionManagementService.getSuggestion(suggestionId).orElseThrow(() -> new SuggestionNotFoundException(suggestionId));
@@ -79,9 +81,6 @@ public class SuggestionServiceBean implements SuggestionService {
log.error("Failed to post suggestion {}", suggestionId, throwable);
return null;
});
} else {
log.warn("Guild {} or member {} was not found when creating suggestion.", member.getGuild().getIdLong(), member.getIdLong());
}
}
@Override
@@ -92,6 +91,7 @@ public class SuggestionServiceBean implements SuggestionService {
}
private void updateSuggestion(String text, SuggestionLog suggestionLog, Suggestion suggestion) {
suggestionLog.setSuggesterUser(suggestion.getSuggester());
Long channelId = suggestion.getChannel().getId();
Long originalMessageId = suggestion.getMessageId();
Long serverId = suggestion.getServer().getId();
@@ -100,11 +100,10 @@ public class SuggestionServiceBean implements SuggestionService {
suggestionLog.setOriginalMessageId(originalMessageId);
suggestionLog.setOriginalMessageUrl(MessageUtils.buildMessageUrl(serverId, channelId, originalMessageId));
AUserInAServer suggester = suggestion.getSuggester();
JDA instance = botService.getInstance();
Guild guildById = instance.getGuildById(serverId);
if(guildById != null) {
Optional<Guild> guildByIdOptional = botService.getGuildById(serverId);
if(guildByIdOptional.isPresent()) {
Guild guildById = guildByIdOptional.get();
Member memberById = guildById.getMemberById(suggester.getUserReference().getId());
if(memberById != null) {
suggestionLog.setSuggester(memberById);
suggestionLog.setSuggestion(suggestion);
TextChannel textChannelById = guildById.getTextChannelById(channelId);
@@ -112,8 +111,11 @@ public class SuggestionServiceBean implements SuggestionService {
textChannelById.retrieveMessageById(originalMessageId).queue(message ->
self.updateSuggestionMessageText(text, suggestionLog, message)
);
} else {
log.warn("Not possible to update suggestion {}, because text channel {} was not found in guild {}.", suggestion.getId(), channelId, serverId);
}
}
} else {
log.warn("Not possible to update suggestion {}, because guild {} was not found.", suggestion.getId(), serverId);
}
}
@@ -126,6 +128,9 @@ public class SuggestionServiceBean implements SuggestionService {
suggestionLog.setText(suggestionEmbed.getDescription());
MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_LOG_TEMPLATE, suggestionLog);
postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, suggestionLog.getServer().getId());
} else {
log.warn("The message to update the suggestion for, did not contain an embed to update. Suggestions require an embed with a description as a container. MessageURL: {}", message.getJumpUrl());
throw new SuggestionUpdateException("Not possible to update suggestion.");
}
}
@@ -135,9 +140,4 @@ public class SuggestionServiceBean implements SuggestionService {
suggestionManagementService.setSuggestionState(suggestion, SuggestionState.REJECTED);
updateSuggestion(text, log, suggestion);
}
@Override
public void validateSetup(Long serverId) {
postTargetService.throwIfPostTargetIsNotDefined(SuggestionPostTarget.SUGGESTION, serverId);
}
}

32
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/management/MessageEmbedPostManagementServiceBean.java
View File

@@ -1,10 +1,14 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
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.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.utility.exception.CrossServerEmbedException;
import dev.sheldan.abstracto.utility.models.database.EmbeddedMessage;
import dev.sheldan.abstracto.utility.repository.EmbeddedMessageRepository;
import lombok.extern.slf4j.Slf4j;
@@ -25,13 +29,22 @@ public class MessageEmbedPostManagementServiceBean implements MessageEmbedPostMa
@Autowired
private UserInServerManagementService userInServerManagementService;
@Autowired
private ServerManagementService serverManagementService;
@Autowired
private ChannelManagementService channelManagementService;
@Override
@Transactional
public void createMessageEmbed(CachedMessage embeddedMessage, Message messageContainingEmbed, AUserInAServer cause) {
AServer embeddedServer = AServer.builder().id(embeddedMessage.getServerId()).build();
AChannel embeddedChannel = AChannel.builder().id(embeddedMessage.getChannelId()).build();
AServer embeddingServer = AServer.builder().id(messageContainingEmbed.getGuild().getIdLong()).build();
AChannel embeddingChannel = AChannel.builder().id(messageContainingEmbed.getTextChannel().getIdLong()).build();
public void createMessageEmbed(CachedMessage embeddedMessage, Message messageContainingEmbed, AUserInAServer embeddingUser) {
AServer embeddedServer = serverManagementService.loadOrCreate(embeddedMessage.getServerId());
AServer embeddingServer = serverManagementService.loadOrCreate(messageContainingEmbed.getGuild().getIdLong());
if(!embeddedServer.getId().equals(embeddingServer.getId())) {
throw new CrossServerEmbedException(String.format("Message %s is not from server %s", embeddedMessage.getMessageUrl(), embeddingServer.getId()));
}
AChannel embeddingChannel = channelManagementService.loadChannel(messageContainingEmbed.getChannel().getIdLong()).orElseThrow(() -> new ChannelNotFoundException(messageContainingEmbed.getChannel().getIdLong(), messageContainingEmbed.getGuild().getIdLong()));
AChannel embeddedChannel = channelManagementService.loadChannel(embeddedMessage.getChannelId()).orElseThrow(() -> new ChannelNotFoundException(embeddedMessage.getChannelId(), embeddedMessage.getServerId()));
AUserInAServer embeddedAuthor = userInServerManagementService.loadUser(embeddedMessage.getServerId(), embeddedMessage.getAuthorId());
EmbeddedMessage messageEmbedPost = EmbeddedMessage
.builder()
@@ -42,7 +55,7 @@ public class MessageEmbedPostManagementServiceBean implements MessageEmbedPostMa
.embeddingChannel(embeddingChannel)
.embeddingMessageId(messageContainingEmbed.getIdLong())
.embeddedUser(embeddedAuthor)
.embeddingUser(cause)
.embeddingUser(embeddingUser)
.build();
embeddedMessageRepository.save(messageEmbedPost);
@@ -54,14 +67,9 @@ public class MessageEmbedPostManagementServiceBean implements MessageEmbedPostMa
}
@Override
@Transactional
public void deleteEmbeddedMessage(EmbeddedMessage embeddedMessage) {
embeddedMessageRepository.delete(embeddedMessage);
}
@Override
@Transactional
public void deleteEmbeddedMessageTransactional(EmbeddedMessage embeddedMessage) {
this.deleteEmbeddedMessage(embeddedMessage);
}
}

4
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/management/ReminderManagementServiceBean.java
View File

@@ -56,8 +56,8 @@ public class ReminderManagementServiceBean implements ReminderManagementService
}
@Override
public Reminder getReminderByAndByUserNotReminded(AUserInAServer aUserInAServer, Long reminderId) {
return reminderRepository.getByIdAndRemindedUserAndRemindedFalse(reminderId, aUserInAServer);
public Optional<Reminder> getReminderByAndByUserNotReminded(AUserInAServer aUserInAServer, Long reminderId) {
return Optional.ofNullable(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(reminderId, aUserInAServer));
}

13
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/management/StarboardPostManagementServiceBean.java
View File

@@ -1,9 +1,11 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
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.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.repository.StarboardPostRepository;
import org.springframework.beans.factory.annotation.Autowired;
@@ -21,15 +23,20 @@ public class StarboardPostManagementServiceBean implements StarboardPostManageme
@Autowired
private StarboardPostRepository repository;
@Autowired
private ChannelManagementService channelManagementService;
@Override
public StarboardPost createStarboardPost(CachedMessage starredMessage, AUserInAServer starredUser, AUserInAServer starringUser, AServerAChannelMessage starboardPost) {
public StarboardPost createStarboardPost(CachedMessage starredMessage, AUserInAServer starredUser, AServerAChannelMessage starboardPost) {
AChannel build = channelManagementService.loadChannel(starredMessage.getChannelId()).orElseThrow(() -> new ChannelNotFoundException(starredMessage.getChannelId(), starredMessage.getServerId()));
StarboardPost post = StarboardPost
.builder()
.author(starredUser)
.postMessageId(starredMessage.getMessageId())
.sourceChanel(build)
.ignored(false)
.starboardMessageId(starboardPost.getMessageId())
.starboardChannel(starboardPost.getChannel())
.sourceChanel(AChannel.builder().id(starredMessage.getChannelId()).build())
.starredDate(Instant.now())
.build();
repository.save(post);
@@ -79,7 +86,7 @@ public class StarboardPostManagementServiceBean implements StarboardPostManageme
@Override
public boolean isStarboardPost(Long messageId) {
return repository.findByStarboardMessageId(messageId) != null;
return repository.existsByStarboardMessageId(messageId);
}
@Override

8
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/management/SuggestionManagementServiceBean.java
View File

@@ -5,7 +5,6 @@ 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.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.SuggestionState;
@@ -45,6 +44,7 @@ public class SuggestionManagementServiceBean implements SuggestionManagementServ
.builder()
.state(SuggestionState.NEW)
.suggester(suggester)
.server(suggester.getServerReference())
.suggestionDate(Instant.now())
.build();
suggestionRepository.save(suggestion);
@@ -59,16 +59,14 @@ public class SuggestionManagementServiceBean implements SuggestionManagementServ
@Override
public void setPostedMessage(Suggestion suggestion, Message message) {
suggestion.setMessageId(message.getIdLong());
long channelId = message.getTextChannel().getIdLong();
long channelId = message.getChannel().getIdLong();
Optional<AChannel> channelOptional = channelManagementService.loadChannel(channelId);
if(channelOptional.isPresent()) {
suggestion.setChannel(channelOptional.get());
} else {
throw new ChannelNotFoundException(channelId, suggestion.getServer().getId());
}
AServer server = serverManagementService.loadOrCreate(message.getGuild().getIdLong());
suggestion.setServer(server);
suggestion.setMessageId(message.getIdLong());
suggestionRepository.save(suggestion);
}

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

@@ -20,7 +20,8 @@ public class StarboardFeatureValidatorService implements StarboardFeatureValidat
@Override
public void featureIsSetup(FeatureConfig featureConfig, AServer server, FeatureValidationResult validationResult) {
for(int i = starboardConfig.getLvl().size(); i > 0; i--) {
int levelAmount = starboardConfig.getLvl().size();
for(int i = 1; i <= levelAmount; i++) {
featureValidatorService.checkSystemConfig("starLvl" + i, server, validationResult);
}
}

4
abstracto-application/abstracto-modules/utility/utility-impl/src/main/resources/templates/commands/suggest/suggest_log_embed_en_US.ftl
View File

@@ -1,7 +1,11 @@
{
"author": {
<#if suggester?has_content>
"name": "${suggester.effectiveName}",
"avatar": "${suggester.user.effectiveAvatarUrl}"
<#else>
"name": "${suggesterUser.userReference.id}"
</#if>
},
"color" : {
"r": 200,

33
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/ServerInfoTest.java Normal file
View File

@@ -0,0 +1,33 @@
package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.serverinfo.ServerInfoModel;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class ServerInfoTest {
@InjectMocks
private ServerInfo testUnit;
@Mock
private ChannelService channelService;
@Test
public void executeCommand() {
CommandContext context = CommandTestUtilities.getNoParameters();
CommandResult result = testUnit.execute(context);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq("serverinfo_response"), any(ServerInfoModel.class), eq(context.getChannel()));
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

58
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/ShowAvatarTest.java Normal file
View File

@@ -0,0 +1,58 @@
package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.ShowAvatarModel;
import net.dv8tion.jda.api.entities.Member;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class ShowAvatarTest {
@InjectMocks
private ShowAvatar testUnit;
@Mock
private ChannelService channelService;
@Captor
private ArgumentCaptor<ShowAvatarModel> argumentCaptor;
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void executeWithoutParameter() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
CommandResult result = testUnit.execute(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(ShowAvatar.SHOW_AVATAR_RESPONSE_TEMPLATE), argumentCaptor.capture(), eq(noParameters.getChannel()));
ShowAvatarModel usedModel = argumentCaptor.getValue();
Assert.assertEquals(noParameters.getAuthor(), usedModel.getMemberInfo());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
@Test
public void executeWithParameter() {
Member target = Mockito.mock(Member.class);
CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(target));
CommandResult result = testUnit.execute(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(ShowAvatar.SHOW_AVATAR_RESPONSE_TEMPLATE), argumentCaptor.capture(), eq(noParameters.getChannel()));
ShowAvatarModel usedModel = argumentCaptor.getValue();
Assert.assertEquals(target, usedModel.getMemberInfo());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

66
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/ShowEmoteTest.java Normal file
View File

@@ -0,0 +1,66 @@
package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.ShowEmoteLog;
import net.dv8tion.jda.api.entities.Emote;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class ShowEmoteTest {
@InjectMocks
private ShowEmote testUnit;
@Mock
private ChannelService channelService;
@Captor
private ArgumentCaptor<ShowEmoteLog> emoteLogArgumentCaptor;
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test
public void executeCommandWithOneEmote() {
Emote emote = Mockito.mock(Emote.class);
CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(emote));
CommandResult result = testUnit.execute(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(ShowEmote.SHOW_EMOTE_RESPONSE_TEMPLATE), emoteLogArgumentCaptor.capture(), eq(noParameters.getChannel()));
CommandTestUtilities.checkSuccessfulCompletion(result);
ShowEmoteLog usedLog = emoteLogArgumentCaptor.getValue();
Assert.assertEquals(emote, usedLog.getEmote());
}
@Test
public void executeCommandWithTwoEmotes() {
Emote emote = Mockito.mock(Emote.class);
Emote secondEmote = Mockito.mock(Emote.class);
CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(emote, secondEmote));
CommandResult result = testUnit.execute(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(ShowEmote.SHOW_EMOTE_RESPONSE_TEMPLATE), emoteLogArgumentCaptor.capture(), eq(noParameters.getChannel()));
CommandTestUtilities.checkSuccessfulCompletion(result);
ShowEmoteLog usedLog = emoteLogArgumentCaptor.getValue();
Assert.assertEquals(emote, usedLog.getEmote());
}
}

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

@@ -0,0 +1,40 @@
package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsModel;
import dev.sheldan.abstracto.utility.service.StarboardService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarStatsTest {
@InjectMocks
private StarStats testUnit;
@Mock
private StarboardService starboardService;
@Mock
private ChannelService channelService;
@Test
public void executeCommand() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
when(noParameters.getGuild().getIdLong()).thenReturn(noParameters.getUserInitiatedContext().getChannel().getId());
StarStatsModel starStatsModel = StarStatsModel.builder().build();
when(starboardService.retrieveStarStats(noParameters.getGuild().getIdLong())).thenReturn(starStatsModel);
CommandResult result = testUnit.execute(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(StarStats.STARSTATS_RESPONSE_TEMPLATE, starStatsModel, noParameters.getChannel());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

94
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/UserInfoTest.java Normal file
View File

@@ -0,0 +1,94 @@
package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.UserInfoModel;
import net.dv8tion.jda.api.entities.Member;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class UserInfoTest {
@InjectMocks
private UserInfo testUnit;
@Mock
private ChannelService channelService;
@Mock
private BotService botService;
@Mock
private UserInfo self;
@Captor
private ArgumentCaptor<UserInfoModel> modelArgumentCaptor;
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void executeWithoutParameterAndLoadedMember() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
when(noParameters.getAuthor().hasTimeJoined()).thenReturn(true);
CommandResult result = testUnit.execute(noParameters);
verify(self, times(1)).sendResponse(eq(noParameters), modelArgumentCaptor.capture());
UserInfoModel usedModel = modelArgumentCaptor.getValue();
Assert.assertEquals(noParameters.getAuthor(), usedModel.getMemberInfo());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
@Test
public void executeWithoutParameterWithoutLoadedMember() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
when(noParameters.getAuthor().hasTimeJoined()).thenReturn(false);
Member loadedAuthor = Mockito.mock(Member.class);
when(botService.forceReloadMember(noParameters.getAuthor())).thenReturn(CompletableFuture.completedFuture(loadedAuthor));
CommandResult result = testUnit.execute(noParameters);
verify(self, times(1)).sendResponse(eq(noParameters), modelArgumentCaptor.capture());
UserInfoModel usedModel = modelArgumentCaptor.getValue();
Assert.assertEquals(loadedAuthor, usedModel.getMemberInfo());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
@Test
public void executeTestWithParameterLoadedMember() {
Member member = Mockito.mock(Member.class);
when(member.hasTimeJoined()).thenReturn(true);
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(member));
CommandResult result = testUnit.execute(parameters);
verify(self, times(1)).sendResponse(eq(parameters), modelArgumentCaptor.capture());
UserInfoModel usedModel = modelArgumentCaptor.getValue();
Assert.assertEquals(member, usedModel.getMemberInfo());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
@Test
public void executeWithParameterWithoutLoadedMember() {
Member member = Mockito.mock(Member.class);
when(member.hasTimeJoined()).thenReturn(false);
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(member));
Member loadedAuthor = Mockito.mock(Member.class);
when(botService.forceReloadMember(member)).thenReturn(CompletableFuture.completedFuture(loadedAuthor));
CommandResult result = testUnit.execute(parameters);
verify(self, times(1)).sendResponse(eq(parameters), modelArgumentCaptor.capture());
UserInfoModel usedModel = modelArgumentCaptor.getValue();
Assert.assertEquals(loadedAuthor, usedModel.getMemberInfo());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

70
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/remind/RemindTest.java Normal file
View File

@@ -0,0 +1,70 @@
package dev.sheldan.abstracto.utility.commands.remind;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.ReminderModel;
import dev.sheldan.abstracto.utility.service.ReminderService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Duration;
import java.util.Arrays;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class RemindTest {
@InjectMocks
private Remind testUnit;
@Mock
private ReminderService remindService;
@Mock
private ChannelService channelService;
@Captor
private ArgumentCaptor<ReminderModel> captor;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test(expected = InsufficientParameters.class)
public void testOnlyRemindDateParameter() {
CommandContext durationParameter = CommandTestUtilities.getWithParameters(Arrays.asList(Duration.ofDays(4)));
testUnit.execute(durationParameter);
}
@Test
public void executeCommand() {
String reminderText = "text";
Duration duration = Duration.ofMinutes(10);
CommandContext withParameters = CommandTestUtilities.getWithParameters(Arrays.asList(duration, reminderText));
CommandResult result = testUnit.execute(withParameters);
verify(remindService, times(1)).createReminderInForUser(withParameters.getUserInitiatedContext().getAUserInAServer(), reminderText, duration, withParameters.getMessage());
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(Remind.REMINDER_EMBED_KEY), captor.capture(), eq(withParameters.getChannel()));
ReminderModel reminderModel = captor.getValue();
Assert.assertEquals(reminderText, reminderModel.getRemindText());
Assert.assertEquals(withParameters.getMessage(), reminderModel.getMessage());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

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

@@ -0,0 +1,54 @@
package dev.sheldan.abstracto.utility.commands.remind;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.RemindersModel;
import dev.sheldan.abstracto.utility.service.management.ReminderManagementService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class RemindersTest {
@InjectMocks
private Reminders testUnit;
@Mock
private ReminderManagementService reminderManagementService;
@Mock
private ChannelService channelService;
@Captor
private ArgumentCaptor<RemindersModel> modelCaptor;
@Test
public void testExecuteCommand() {
CommandContext context = CommandTestUtilities.getNoParameters();
Reminder reminder = Reminder.builder().build();
Reminder secondReminder = Reminder.builder().build();
List<Reminder> reminders = Arrays.asList(reminder, secondReminder);
when(reminderManagementService.getActiveRemindersForUser(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(reminders);
CommandResult result = testUnit.execute(context);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(Reminders.REMINDERS_RESPONSE_TEMPLATE), modelCaptor.capture(), eq(context.getChannel()));
RemindersModel usedModel = modelCaptor.getValue();
Assert.assertEquals(reminder, usedModel.getReminders().get(0));
Assert.assertEquals(secondReminder, usedModel.getReminders().get(1));
Assert.assertEquals(reminders.size(), usedModel.getReminders().size());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

46
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/remind/UnRemindTest.java Normal file
View File

@@ -0,0 +1,46 @@
package dev.sheldan.abstracto.utility.commands.remind;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.service.ReminderService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class UnRemindTest {
@InjectMocks
private UnRemind testUnit;
@Mock
private ReminderService reminderService;
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test
public void testExecuteCommand() {
Long reminderId = 6L;
CommandContext withParameters = CommandTestUtilities.getWithParameters(Arrays.asList(reminderId));
CommandResult result = testUnit.execute(withParameters);
verify(reminderService, times(1)).unRemind(reminderId, withParameters.getUserInitiatedContext().getAUserInAServer());
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

51
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/suggest/AcceptTest.java Normal file
View File

@@ -0,0 +1,51 @@
package dev.sheldan.abstracto.utility.commands.suggest;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.SuggestionService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@RunWith(MockitoJUnitRunner.class)
public class AcceptTest {
@InjectMocks
private Accept testUnit;
@Mock
private SuggestionService suggestionService;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testExecuteCommand() {
String text = "text";
Long suggestionId = 5L;
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(suggestionId, text));
CommandResult result = testUnit.execute(context);
verify(suggestionService, times(1)).acceptSuggestion(eq(suggestionId), eq(text), any(SuggestionLog.class));
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

51
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/suggest/RejectTest.java Normal file
View File

@@ -0,0 +1,51 @@
package dev.sheldan.abstracto.utility.commands.suggest;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.SuggestionService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@RunWith(MockitoJUnitRunner.class)
public class RejectTest {
@InjectMocks
private Reject testUnit;
@Mock
private SuggestionService suggestionService;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testExecuteCommand() {
String text = "text";
Long suggestionId = 5L;
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(suggestionId, text));
CommandResult result = testUnit.execute(context);
verify(suggestionService, times(1)).rejectSuggestion(eq(suggestionId), eq(text), any(SuggestionLog.class));
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

48
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/suggest/SuggestTest.java Normal file
View File

@@ -0,0 +1,48 @@
package dev.sheldan.abstracto.utility.commands.suggest;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.InsufficientParameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.SuggestionService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class SuggestTest {
@InjectMocks
private Suggest testUnit;
@Mock
private SuggestionService suggestionService;
@Test(expected = InsufficientParameters.class)
public void testTooLittleParameters() {
CommandTestUtilities.executeNoParametersTest(testUnit);
}
@Test(expected = IncorrectParameter.class)
public void testIncorrectParameterType() {
CommandTestUtilities.executeWrongParametersTest(testUnit);
}
@Test
public void testExecuteCommand() {
String text = "text";
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(text));
CommandResult result = testUnit.execute(context);
verify(suggestionService, times(1)).createSuggestion(eq(context.getAuthor()), eq(text), any(SuggestionLog.class));
CommandTestUtilities.checkSuccessfulCompletion(result);
}
}

50
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/config/StarboardConfigListenerTest.java Normal file
View File

@@ -0,0 +1,50 @@
package dev.sheldan.abstracto.utility.config;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.service.StarboardServiceBean;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardConfigListenerTest {
@InjectMocks
private StarboardConfigListener testUnit;
@Mock
private StarboardConfig starboardConfig;
@Mock
private ConfigManagementService configManagementService;
@Captor
private ArgumentCaptor<String> configKeyCaptor;
@Test
public void testUpdateServerConfig() {
AServer server = MockUtils.getServer();
List<Integer> levels = Arrays.asList(1, 2, 3);
when(starboardConfig.getLvl()).thenReturn(levels);
testUnit.updateServerConfig(server);
verify(configManagementService, times(levels.size())).createIfNotExists(eq(server.getId()), configKeyCaptor.capture(), anyLong());
List<String> keys = configKeyCaptor.getAllValues();
for (int i = 0; i < levels.size(); i++) {
Assert.assertEquals(StarboardServiceBean.STAR_LVL_CONFIG_PREFIX + (i + 1), keys.get(i));
}
Assert.assertEquals(levels.size(), keys.size());
}
}

47
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/config/StarboardDefaultConfigListenerTest.java Normal file
View File

@@ -0,0 +1,47 @@
package dev.sheldan.abstracto.utility.config;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.utility.service.StarboardServiceBean;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardDefaultConfigListenerTest {
@InjectMocks
private StarboardDefaultConfigListener testUnit;
@Mock
private DefaultConfigManagementService defaultConfigManagementService;
@Mock
private StarboardConfig starboardConfig;
@Captor
private ArgumentCaptor<String> configKeyCaptor;
@Test
public void testDefaultConfig() {
List<Integer> levels = Arrays.asList(1, 2, 3);
when(starboardConfig.getLvl()).thenReturn(levels);
testUnit.handleContextRefreshEvent(null);
verify(defaultConfigManagementService, times(levels.size())).createDefaultConfig(configKeyCaptor.capture(), anyLong());
List<String> keys = configKeyCaptor.getAllValues();
for (int i = 0; i < levels.size(); i++) {
Assert.assertEquals(StarboardServiceBean.STAR_LVL_CONFIG_PREFIX + (i + 1), keys.get(i));
}
Assert.assertEquals(levels.size(), keys.size());
}
}

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

@@ -0,0 +1,229 @@
package dev.sheldan.abstracto.utility.listener.embed;
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.management.UserInServerManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.models.MessageEmbedLink;
import dev.sheldan.abstracto.utility.service.MessageEmbedService;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import net.dv8tion.jda.internal.requests.restaction.AuditableRestActionImpl;
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.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
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 UserInServerManagementService userInServerManagementService;
@Mock
private MessageEmbedService messageEmbedService;
@Mock
private MessageEmbedListener self;
@Mock
private Message message;
@Mock
private AuditableRestActionImpl<Void> deletionRestAction;
@Mock
private TextChannel textChannel;
@Mock
private Guild guild;
@Before
public void setup(){
when(guild.getIdLong()).thenReturn(ORIGIN_GUILD_ID);
when(message.getGuild()).thenReturn(guild);
}
@Test
public void testNoLinkFoundExecution() {
String text = "text";
when(message.getContentRaw()).thenReturn(text);
List<MessageEmbedLink> foundMessageLinks = new ArrayList<>();
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(message, times(0)).delete();
}
@Test
public void testOnlyOneLinkFoundExecution() {
String linkText = "link";
String text = linkText;
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, ORIGIN_GUILD_ID);
verify(self, times(1)).loadUserAndEmbed(eq(message), anyLong(), any(CachedMessage.class));
verify(message, times(1)).delete();
verify(deletionRestAction, times(1)).queue();
}
@Test
public void testOneLinkWithAdditionalTextExecution() {
String linkText = "link";
String text = linkText + "more text";
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, ORIGIN_GUILD_ID);
verify(self, times(1)).loadUserAndEmbed(eq(message), anyLong(), any(CachedMessage.class));
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
}
@Test
public void testLinkFromDifferentServer() {
String linkText = "link";
String text = linkText + "more text";
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, EMBEDDING_GUILD_ID);
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
verify(self, times(0)).loadUserAndEmbed(eq(message), anyLong(), any(CachedMessage.class));
verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
}
@Test
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();
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(differentOriginLink, sameServerLink);
AUserInAServer embeddingUser = MockUtils.getUserObject(4L, embeddingServer);
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(userInServerManagementService.loadUser(author)).thenReturn(embeddingUser);
CachedMessage cachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(embeddingServer.getId(), embeddingChannel.getId(), secondMessageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageEmbedService.getLinksInMessage(completeMessage)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
verify(self, times(1)).loadUserAndEmbed(message, embeddingUser.getUserInServerId(), 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();
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(foundLink, secondLink);
AUserInAServer userInAServer = MockUtils.getUserObject(4L, server);
when(message.getContentRaw()).thenReturn(text);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(message.delete()).thenReturn(deletionRestAction);
when(userInServerManagementService.loadUser(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));
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(message, times(1)).delete();
verify(deletionRestAction, times(1)).queue();
verify(self, times(1)).loadUserAndEmbed(message, userInAServer.getUserInServerId(), cachedMessage);
verify(self, times(1)).loadUserAndEmbed(message, userInAServer.getUserInServerId(), secondCachedMessage);
}
@Test
public void testLoadUserAndEmbed() {
CachedMessage cachedMessage = CachedMessage.builder().build();
long userId = 3L;
when(message.getTextChannel()).thenReturn(textChannel);
testUnit.loadUserAndEmbed(message, userId, cachedMessage);
verify(messageEmbedService, times(1)).embedLink(cachedMessage, textChannel, userId, message);
}
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);
when(message.getContentRaw()).thenReturn(text);
Long messageId = 4L;
MessageEmbedLink foundLink = MessageEmbedLink
.builder()
.serverId(embeddingServer.getId())
.channelId(channel.getId())
.messageId(messageId)
.wholeUrl(linkText)
.build();
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(foundLink);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(message.delete()).thenReturn(deletionRestAction);
when(userInServerManagementService.loadUser(author)).thenReturn(userInAServer);
CachedMessage cachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(originServer.getId(), channel.getId(), messageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
}
}

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

@@ -0,0 +1,142 @@
package dev.sheldan.abstracto.utility.listener.embed;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.EmbeddedMessage;
import dev.sheldan.abstracto.utility.service.management.MessageEmbedPostManagementService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.MessageReaction;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class MessageEmbedRemovalReactionListenerTest {
@InjectMocks
private MessageEmbedRemovalReactionListener testUnit;
@Mock
private BotService botService;
@Mock
private MessageEmbedPostManagementService messageEmbedPostManagementService;
@Mock
private MessageService messageService;
@Mock
private EmoteService emoteService;
@Mock
private MessageReaction messageReaction;
@Mock
private MessageReaction.ReactionEmote reactionEmote;
@Mock
private Emote emote;
@Test
public void testAddingWrongEmote() {
Long messageId = 4L;
executeRemovalAddedTest(false, messageId);
verify(messageEmbedPostManagementService, times(0)).findEmbeddedPostByMessageId(messageId);
}
@Test
public void testAddingCorrectEmoteToWrongMessage() {
Long messageId = 4L;
when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(messageId)).thenReturn(Optional.empty());
executeRemovalAddedTest(true, messageId);
}
@Test
public void testIncorrectUserAddingReaction() {
Long serverId = 4L;
AServer server = MockUtils.getServer(serverId);
AUserInAServer embeddingUser = MockUtils.getUserObject(6L, server);
AUserInAServer embeddedUser = MockUtils.getUserObject(7L, server);
executeDeletionTest(serverId, 5L, embeddingUser, embeddedUser, MockUtils.getUserObject(5L, server), 0);
}
@Test
public void testEmbeddedUserAddingReaction() {
Long serverId = 4L;
AServer server = MockUtils.getServer(serverId);
AUserInAServer embeddingUser = MockUtils.getUserObject(6L, server);
AUserInAServer embeddedUser = MockUtils.getUserObject(7L, server);
executeDeletionTest(serverId, 4L, embeddingUser, embeddedUser, embeddedUser, 1);
}
@Test
public void testEmbeddingUserAddingReaction() {
Long serverId = 4L;
AServer server = MockUtils.getServer(serverId);
AUserInAServer embeddingUser = MockUtils.getUserObject(6L, server);
AUserInAServer embeddedUser = MockUtils.getUserObject(7L, server);
executeDeletionTest(serverId, 5L, embeddingUser, embeddedUser, embeddingUser, 1);
}
private void executeDeletionTest(Long serverId, Long channelId, AUserInAServer embeddingUser, AUserInAServer embeddedUser, AUserInAServer userAddingReaction, int wantedDeletions) {
Long messageId = 4L;
CachedMessage cachedMessage = CachedMessage
.builder()
.serverId(serverId)
.messageId(messageId)
.channelId(channelId)
.build();
AEmote reactedEmote = AEmote.builder().build();
when(emoteService.getEmoteOrFakeEmote(MessageEmbedRemovalReactionListener.REMOVAL_EMOTE, serverId)).thenReturn(reactedEmote);
when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
when(botService.getEmote(serverId, reactedEmote)).thenReturn(Optional.of(emote));
when(emoteService.isReactionEmoteAEmote(reactionEmote, reactedEmote, emote)).thenReturn(true);
EmbeddedMessage message = EmbeddedMessage
.builder()
.embeddingUser(embeddingUser)
.embeddedUser(embeddedUser)
.build();
when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(messageId)).thenReturn(Optional.of(message));
when(messageService.deleteMessageInChannelInServer(serverId, channelId, messageId)).thenReturn(CompletableFuture.completedFuture(null));
when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(messageId)).thenReturn(Optional.of(message));
testUnit.executeReactionAdded(cachedMessage, messageReaction, userAddingReaction);
verify(messageService, times(wantedDeletions)).deleteMessageInChannelInServer(serverId, channelId, messageId);
if(wantedDeletions > 0) {
verify(messageEmbedPostManagementService, times(1)).deleteEmbeddedMessage(message);
}
}
private void executeRemovalAddedTest(boolean wasCorrectEmote, Long messageId) {
Long serverId = 4L;
AServer server = MockUtils.getServer(serverId);
Long channelId = 5L;
CachedMessage cachedMessage = CachedMessage
.builder()
.serverId(serverId)
.messageId(messageId)
.channelId(channelId)
.build();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
AEmote reactedEmote = AEmote.builder().build();
when(emoteService.getEmoteOrFakeEmote(MessageEmbedRemovalReactionListener.REMOVAL_EMOTE, serverId)).thenReturn(reactedEmote);
when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
when(botService.getEmote(serverId, reactedEmote)).thenReturn(Optional.of(emote));
when(emoteService.isReactionEmoteAEmote(reactionEmote, reactedEmote, emote)).thenReturn(wasCorrectEmote);
testUnit.executeReactionAdded(cachedMessage, messageReaction, userInAServer);
verify(messageService, times(0)).deleteMessageInChannelInServer(serverId, channelId, messageId);
}
}

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

@@ -0,0 +1,291 @@
package dev.sheldan.abstracto.utility.listener.starboard;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReaction;
import dev.sheldan.abstracto.core.models.database.AConfig;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.service.StarboardService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostManagementService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostReactorManagementService;
import net.dv8tion.jda.api.entities.MessageReaction;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardListenerTest {
@InjectMocks
private StarboardListener testUnit;
@Mock
private BotService botService;
@Mock
private ConfigManagementService configManagementService;
@Mock
private StarboardService starboardService;
@Mock
private StarboardPostManagementService starboardPostManagementService;
@Mock
private StarboardPostReactorManagementService starboardPostReactorManagementService;
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private EmoteService emoteService;
@Mock
private MessageReaction messageReaction;
@Mock
private MessageReaction.ReactionEmote reactionEmote;
@Test
public void testAuthorAddingStar() {
Long serverId = 5L;
Long authorId = 4L;
CachedMessage cachedMessage = CachedMessage
.builder()
.authorId(authorId)
.serverId(serverId)
.build();
AUserInAServer userAdding = MockUtils.getUserObject(authorId, MockUtils.getServer(serverId));
testUnit.executeReactionAdded(cachedMessage, messageReaction, userAdding);
verify(emoteService, times(0)).getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId);
}
@Test
public void testAddingWrongEmote() {
Long serverId = 5L;
Long authorId = 4L;
Long reactionUserId = 7L;
AEmote starEmote = AEmote.builder().build();
AUserInAServer userAdding = MockUtils.getUserObject(reactionUserId, MockUtils.getServer(serverId));
CachedMessage cachedMessage = setupWrongEmote(serverId, authorId, starEmote);
testUnit.executeReactionAdded(cachedMessage, messageReaction, userAdding);
verify(emoteService, times(1)).getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId);
verify(emoteService, times(0)).getReactionFromMessageByEmote(any(CachedMessage.class), eq(starEmote));
}
@Test
public void testAddingEmoteToExistingPostButNowBelowThreshold() {
Long requiredStars = 5L;
AServer server = MockUtils.getServer();
AUserInAServer userAdding = MockUtils.getUserObject(7L, server);
AUserInAServer author = MockUtils.getUserObject(8L, server);
StarboardPost post = StarboardPost.builder().build();
executeAddingTest(userAdding, author, requiredStars, post);
verify(starboardService, times(1)).deleteStarboardMessagePost(post);
verify(starboardPostManagementService, times(1)).removePost(post);
}
@Test
public void testAddingEmoteBelowThreshold() {
Long requiredStars = 5L;
AServer server = MockUtils.getServer();
AUserInAServer userAdding = MockUtils.getUserObject(7L, server);
AUserInAServer author = MockUtils.getUserObject(8L, server);
executeAddingTest(userAdding, author, requiredStars, null);
verify(starboardService, times(0)).deleteStarboardMessagePost(any(StarboardPost.class));
verify(starboardPostManagementService, times(0)).removePost(any(StarboardPost.class));
}
@Test
public void testAddingEmoteReachingThreshold() {
Long requiredStars = 1L;
AServer server = MockUtils.getServer();
AUserInAServer userAdding = MockUtils.getUserObject(7L, server);
AUserInAServer author = MockUtils.getUserObject(8L, server);
executeAddingTest(userAdding, author, requiredStars, null);
verify(starboardService, times(1)).createStarboardPost(any(CachedMessage.class), anyList(), eq(userAdding), eq(author));
}
@Test
public void testAddingEmoteToExistingPost() {
Long requiredStars = 1L;
AServer server = MockUtils.getServer();
AUserInAServer userAdding = MockUtils.getUserObject(7L, server);
AUserInAServer author = MockUtils.getUserObject(8L, server);
StarboardPost post = StarboardPost.builder().build();
executeAddingTest(userAdding, author, requiredStars, post);
verify(starboardService, times(1)).updateStarboardPost(eq(post), any(CachedMessage.class), anyList());
verify(starboardPostReactorManagementService, times(1)).addReactor(post, userAdding);
}
@Test
public void testAuthorRemovingReaction() {
Long serverId = 5L;
Long authorId = 4L;
CachedMessage cachedMessage = CachedMessage
.builder()
.authorId(authorId)
.serverId(serverId)
.build();
AUserInAServer userAdding = MockUtils.getUserObject(authorId, MockUtils.getServer(serverId));
testUnit.executeReactionRemoved(cachedMessage, messageReaction, userAdding);
verify(emoteService, times(0)).getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId);
}
@Test
public void testRemovingWrongEmote() {
Long serverId = 5L;
Long authorId = 4L;
Long reactionUserId = 7L;
AEmote starEmote = AEmote.builder().build();
AUserInAServer userAdding = MockUtils.getUserObject(reactionUserId, MockUtils.getServer(serverId));
CachedMessage cachedMessage = setupWrongEmote(serverId, authorId, starEmote);
testUnit.executeReactionRemoved(cachedMessage, messageReaction, userAdding);
verify(emoteService, times(1)).getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId);
verify(emoteService, times(0)).getReactionFromMessageByEmote(any(CachedMessage.class), eq(starEmote));
}
@Test
public void testRemoveReactionFromExistingPostBelowThreshold() {
Long requiredStars = 5L;
AServer server = MockUtils.getServer();
AUserInAServer userRemoving = MockUtils.getUserObject(7L, server);
List<Long> remainingUsers = Arrays.asList(userRemoving.getUserReference().getId());
AUserInAServer author = MockUtils.getUserObject(8L, server);
StarboardPost post = StarboardPost.builder().build();
executeRemovalTest(requiredStars, userRemoving, remainingUsers, userRemoving, author, post);
verify(starboardService, times(1)).deleteStarboardMessagePost(eq(post));
verify(starboardPostManagementService, times(1)).removePost(eq(post));
}
@Test
public void testRemoveReactionFromExistingPostAboveThreshold() {
Long requiredStars = 0L;
AServer server = MockUtils.getServer();
AUserInAServer remainingUser = MockUtils.getUserObject(9L, server);
List<Long> remainingUsers = Arrays.asList(remainingUser.getUserReference().getId());
AUserInAServer userRemoving = MockUtils.getUserObject(7L, server);
AUserInAServer author = MockUtils.getUserObject(8L, server);
StarboardPost post = StarboardPost.builder().build();
executeRemovalTest(requiredStars, remainingUser, remainingUsers, userRemoving, author, post);
verify(starboardService, times(0)).deleteStarboardMessagePost(eq(post));
verify(starboardPostManagementService, times(0)).removePost(eq(post));
}
@Test
public void testRemoveReactionFromExistingPostTriggeringThreshold() {
Long requiredStars = 1L;
AServer server = MockUtils.getServer();
ArrayList<Long> usersRemaining = new ArrayList<>();
AUserInAServer userRemoving = MockUtils.getUserObject(7L, server);
AUserInAServer author = MockUtils.getUserObject(8L, server);
StarboardPost post = StarboardPost.builder().build();
executeRemovalTest(requiredStars, userRemoving, usersRemaining, userRemoving, author, post);
verify(starboardService, times(1)).deleteStarboardMessagePost(eq(post));
verify(starboardPostManagementService, times(1)).removePost(eq(post));
}
@Test
public void testReactionsClearedOnStarredMessage() {
executeClearingTest(StarboardPost.builder().build());
}
@Test
public void testReactionsClearedOnNotStarredMessage() {
executeClearingTest(null);
}
private void executeClearingTest(StarboardPost post) {
Long messageId = 5L;
CachedMessage cachedMessage = CachedMessage
.builder()
.messageId(messageId)
.build();
when(starboardPostManagementService.findByMessageId(messageId)).thenReturn(Optional.ofNullable(post));
testUnit.executeReactionCleared(cachedMessage);
int callCount = post != null ? 1 : 0;
verify(starboardPostReactorManagementService, times(callCount)).removeReactors(post);
verify(starboardService, times(callCount)).deleteStarboardMessagePost(eq(post));
verify(starboardPostManagementService, times(callCount)).removePost(eq(post));
}
private void executeRemovalTest(Long requiredStars, AUserInAServer remainingUser, List<Long> remainingUsers, AUserInAServer userRemoving, AUserInAServer author, StarboardPost post) {
Long messageId = 6L;
Long serverId = userRemoving.getServerReference().getId();
CachedMessage cachedMessage = CachedMessage
.builder()
.authorId(author.getUserReference().getId())
.serverId(serverId)
.messageId(messageId)
.build();
when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
AEmote starEmote = AEmote.builder().build();
when(emoteService.getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId)).thenReturn(starEmote);
when(botService.getEmote(serverId, starEmote)).thenReturn(Optional.empty());
when(emoteService.isReactionEmoteAEmote(reactionEmote, starEmote, null)).thenReturn(true);
CachedReaction reaction = CachedReaction.builder().userInServersIds(remainingUsers).build();
when(emoteService.getReactionFromMessageByEmote(cachedMessage, starEmote)).thenReturn(Optional.of(reaction));
when(starboardPostManagementService.findByMessageId(messageId)).thenReturn(Optional.ofNullable(post));
when(userInServerManagementService.loadUser(serverId, author.getUserReference().getId())).thenReturn(author);
when(userInServerManagementService.loadUser(remainingUser.getUserReference().getId())).thenReturn(Optional.of(remainingUser));
when(configManagementService.loadConfig(serverId, StarboardListener.FIRST_LEVEL_THRESHOLD_KEY)).thenReturn(AConfig.builder().longValue(requiredStars).build());
testUnit.executeReactionRemoved(cachedMessage, messageReaction, userRemoving);
verify(emoteService, times(1)).getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId);
verify(emoteService, times(1)).getReactionFromMessageByEmote(cachedMessage, starEmote);
}
private void executeAddingTest(AUserInAServer userAdding, AUserInAServer author, Long requiredStars, StarboardPost existingPost) {
Long messageId = 6L;
Long serverId = userAdding.getServerReference().getId();
CachedMessage cachedMessage = CachedMessage
.builder()
.authorId(author.getUserReference().getId())
.serverId(serverId)
.messageId(messageId)
.build();
when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
AEmote starEmote = AEmote.builder().build();
when(emoteService.getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId)).thenReturn(starEmote);
when(botService.getEmote(serverId, starEmote)).thenReturn(Optional.empty());
when(emoteService.isReactionEmoteAEmote(reactionEmote, starEmote, null)).thenReturn(true);
CachedReaction reaction = CachedReaction.builder().userInServersIds(Arrays.asList(userAdding.getUserReference().getId())).build();
when(emoteService.getReactionFromMessageByEmote(cachedMessage, starEmote)).thenReturn(Optional.of(reaction));
when(starboardPostManagementService.findByMessageId(messageId)).thenReturn(Optional.ofNullable(existingPost));
when(userInServerManagementService.loadUser(serverId, author.getUserReference().getId())).thenReturn(author);
when(userInServerManagementService.loadUser(userAdding.getUserReference().getId())).thenReturn(Optional.of(userAdding));
when(configManagementService.loadConfig(serverId, StarboardListener.FIRST_LEVEL_THRESHOLD_KEY)).thenReturn(AConfig.builder().longValue(requiredStars).build());
testUnit.executeReactionAdded(cachedMessage, messageReaction, userAdding);
verify(emoteService, times(1)).getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId);
verify(emoteService, times(1)).getReactionFromMessageByEmote(cachedMessage, starEmote);
}
private CachedMessage setupWrongEmote(Long serverId, Long authorId, AEmote starEmote) {
CachedMessage cachedMessage = CachedMessage
.builder()
.authorId(authorId)
.serverId(serverId)
.build();
when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
when(emoteService.getEmoteOrFakeEmote(StarboardListener.STAR_EMOTE, serverId)).thenReturn(starEmote);
when(botService.getEmote(serverId, starEmote)).thenReturn(Optional.empty());
when(emoteService.isReactionEmoteAEmote(reactionEmote, starEmote, null)).thenReturn(false);
return cachedMessage;
}
}

57
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/listener/starboard/StarboardPostDeletedListenerTest.java Normal file
View File

@@ -0,0 +1,57 @@
package dev.sheldan.abstracto.utility.listener.starboard;
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.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.service.management.StarboardPostManagementService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardPostDeletedListenerTest {
@InjectMocks
private StarboardPostDeletedListener testUnit;
@Mock
private StarboardPostManagementService starboardPostManagementService;
@Test
public void deleteNonStarboardPost() {
Long messageId = 4L;
when(starboardPostManagementService.findByStarboardPostId(messageId)).thenReturn(Optional.empty());
CachedMessage cachedMessage = CachedMessage
.builder()
.messageId(messageId)
.build();
testUnit.execute(cachedMessage);
verify( starboardPostManagementService, times(0)).setStarboardPostIgnored(messageId, true);
}
@Test
public void deleteStarboardPost() {
Long messageId = 4L;
AServer server = MockUtils.getServer();
AUserInAServer author = MockUtils.getUserObject(4L, server);
AChannel sourceChannel = MockUtils.getTextChannel(server, 6L);
StarboardPost post = StarboardPost.builder().author(author).postMessageId(5L).sourceChanel(sourceChannel).build();
when(starboardPostManagementService.findByStarboardPostId(messageId)).thenReturn(Optional.of(post));
CachedMessage cachedMessage = CachedMessage
.builder()
.messageId(messageId)
.build();
testUnit.execute(cachedMessage);
verify( starboardPostManagementService, times(1)).setStarboardPostIgnored(messageId, true);
}
}

75
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/repository/converter/StarStatsUserConverterTest.java Normal file
View File

@@ -0,0 +1,75 @@
package dev.sheldan.abstracto.utility.repository.converter;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
import dev.sheldan.abstracto.utility.repository.StarStatsUserResult;
import net.dv8tion.jda.api.entities.Member;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarStatsUserConverterTest {
@InjectMocks
private StarStatsUserConverter testUnit;
@Mock
private BotService botService;
@Test
public void testConversionOfMultipleItems() {
Long serverId = 5L;
Long firstUserId = 5L;
Integer firstStarCount = 5;
Long secondUserId = 9L;
Integer secondStarCount = 10;
List<StarStatsUserResult> results = new ArrayList<>();
StarStatsUserResult firstResult = Mockito.mock(StarStatsUserResult.class);
Member firstMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverId, firstUserId)).thenReturn(firstMember);
when(firstResult.getUserId()).thenReturn(firstUserId);
when(firstResult.getStarCount()).thenReturn(firstStarCount);
results.add(firstResult);
StarStatsUserResult secondResult = Mockito.mock(StarStatsUserResult.class);
Member secondMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverId, secondUserId)).thenReturn(secondMember);
when(secondResult.getUserId()).thenReturn(secondUserId);
when(secondResult.getStarCount()).thenReturn(secondStarCount);
results.add(secondResult);
List<StarStatsUser> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
StarStatsUser firstConverted = starStatsUsers.get(0);
Assert.assertEquals(firstStarCount, firstConverted.getStarCount());
Assert.assertEquals(firstMember, firstConverted.getMember());
Assert.assertEquals(firstUserId, firstConverted.getUser().getId());
StarStatsUser secondConverted = starStatsUsers.get(1);
Assert.assertEquals(secondStarCount, secondConverted.getStarCount());
Assert.assertEquals(secondMember, secondConverted.getMember());
Assert.assertEquals(secondUserId, secondConverted.getUser().getId());
Assert.assertEquals(2, starStatsUsers.size());
}
@Test
public void testConversionOfEmptyList() {
Long serverId = 5L;
List<StarStatsUserResult> results = new ArrayList<>();
List<StarStatsUser> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
verify(botService, times(0)).getMemberInServer(eq(serverId), anyLong());
Assert.assertEquals(0, starStatsUsers.size());
}
}

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

@@ -0,0 +1,243 @@
package dev.sheldan.abstracto.utility.service;
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.models.template.listener.MessageEmbeddedModel;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.service.MessageService;
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.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.models.MessageEmbedLink;
import dev.sheldan.abstracto.utility.service.management.MessageEmbedPostManagementService;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class MessageEmbedServiceBeanTest {
@InjectMocks
private MessageEmbedServiceBean testUnit;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private ServerManagementService serverManagementService;
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private BotService botService;
@Mock
private TemplateService templateService;
@Mock
private ChannelService channelService;
@Mock
private MessageEmbedService self;
@Mock
private MessageCache messageCache;
@Mock
private MessageEmbedPostManagementService messageEmbedPostManagementService;
@Mock
private MessageService messageService;
@Mock
private TextChannel textChannel;
@Mock
private Message embeddingMessage;
@Captor
private ArgumentCaptor<CachedMessage> cachedMessageArgumentCaptor;
private static final String FIRST_LINK_TEXT = "https://discordapp.com/channels/1/2/3";
private static final String SHORTER_LINK_TEXT = "https://discord.com/channels/1/2/3";
private static final String SECOND_LINK_TEXT = "https://discordapp.com/channels/2/3/4";
@Test
public void testNoLinkInString(){
String message = "test";
List<MessageEmbedLink> linksInMessage = testUnit.getLinksInMessage(message);
Assert.assertEquals(0, linksInMessage.size());
}
@Test
public void testDMLinkInString(){
String message = "https://discordapp.com/channels/@me/1/2";
List<MessageEmbedLink> linksInMessage = testUnit.getLinksInMessage(message);
Assert.assertEquals(0, linksInMessage.size());
}
@Test
public void testFindOneLinkInString(){
List<MessageEmbedLink> linksInMessage = testUnit.getLinksInMessage(FIRST_LINK_TEXT);
Assert.assertEquals(1, linksInMessage.size());
MessageEmbedLink firstLink = linksInMessage.get(0);
Assert.assertEquals(1, firstLink.getServerId().intValue());
Assert.assertEquals(2, firstLink.getChannelId().intValue());
Assert.assertEquals(3, firstLink.getMessageId().intValue());
Assert.assertEquals(FIRST_LINK_TEXT, firstLink.getWholeUrl());
}
@Test
public void testNewShortDomain(){
List<MessageEmbedLink> linksInMessage = testUnit.getLinksInMessage(SHORTER_LINK_TEXT);
Assert.assertEquals(1, linksInMessage.size());
MessageEmbedLink firstLink = linksInMessage.get(0);
Assert.assertEquals(1, firstLink.getServerId().intValue());
Assert.assertEquals(2, firstLink.getChannelId().intValue());
Assert.assertEquals(3, firstLink.getMessageId().intValue());
Assert.assertEquals(SHORTER_LINK_TEXT, firstLink.getWholeUrl());
}
@Test
public void testTwoLinksInString(){
String message = String.format("%s %s", FIRST_LINK_TEXT, SECOND_LINK_TEXT);
executeTestWithTwoLinks(message);
}
@Test
public void testLinksWithTextInBetween(){
String message = String.format("%s some more text %s", FIRST_LINK_TEXT, SECOND_LINK_TEXT);
executeTestWithTwoLinks(message);
}
@Test
public void testEmbedNoLinks() {
testUnit.embedLinks(new ArrayList<>(), textChannel, 5L, embeddingMessage);
}
@Test
public void testEmbedSingularLink() {
List<MessageEmbedLink> linksToEmbed = new ArrayList<>();
Long channelId = 6L;
Long serverId = 4L;
Long firstMessageId = 6L;
linksToEmbed.add(MessageEmbedLink.builder().serverId(serverId).channelId(channelId).messageId(firstMessageId).build());
CachedMessage firstCachedMessage = CachedMessage.builder().serverId(serverId).channelId(channelId).messageId(firstMessageId).build();
when(messageCache.getMessageFromCache(serverId,channelId, firstMessageId)).thenReturn(CompletableFuture.completedFuture(firstCachedMessage));
Long embeddingUserId = 5L;
testUnit.embedLinks(linksToEmbed, textChannel, embeddingUserId, embeddingMessage);
verify( self, times(1)).embedLink(eq(firstCachedMessage), eq(textChannel), eq(embeddingUserId) , eq(embeddingMessage));
}
@Test
public void testEmbedMultipleLinks() {
List<MessageEmbedLink> linksToEmbed = new ArrayList<>();
Long channelId = 6L;
Long serverId = 4L;
Long firstMessageId = 6L;
Long secondMessageId = 7L;
linksToEmbed.add(MessageEmbedLink.builder().serverId(serverId).channelId(channelId).messageId(firstMessageId).build());
linksToEmbed.add(MessageEmbedLink.builder().serverId(serverId).channelId(channelId).messageId(secondMessageId).build());
CachedMessage firstCachedMessage = CachedMessage.builder().serverId(serverId).channelId(channelId).messageId(firstMessageId).build();
CachedMessage secondCacheMessage = CachedMessage.builder().serverId(serverId).channelId(channelId).messageId(secondMessageId).build();
when(messageCache.getMessageFromCache(serverId,channelId, firstMessageId)).thenReturn(CompletableFuture.completedFuture(firstCachedMessage));
when(messageCache.getMessageFromCache(serverId,channelId, secondMessageId)).thenReturn(CompletableFuture.completedFuture(secondCacheMessage));
Long embeddingUserId = 5L;
testUnit.embedLinks(linksToEmbed, textChannel, embeddingUserId, embeddingMessage);
verify( self, times(2)).embedLink(cachedMessageArgumentCaptor.capture(), eq(textChannel), eq(embeddingUserId) , eq(embeddingMessage));
List<CachedMessage> cachedMessages = cachedMessageArgumentCaptor.getAllValues();
Assert.assertEquals(2, cachedMessages.size());
CachedMessage firstEmbeddedMessage = cachedMessages.get(0);
Assert.assertEquals(serverId, firstEmbeddedMessage.getServerId());
Assert.assertEquals(channelId, firstEmbeddedMessage.getChannelId());
Assert.assertEquals(firstMessageId, firstEmbeddedMessage.getMessageId());
CachedMessage secondEmbeddedMessage = cachedMessages.get(1);
Assert.assertEquals(serverId, secondEmbeddedMessage.getServerId());
Assert.assertEquals(channelId, secondEmbeddedMessage.getChannelId());
Assert.assertEquals(secondMessageId, secondEmbeddedMessage.getMessageId());
}
@Test
public void testEmbeddingLink() {
Long channelId = 6L;
Long serverId = 4L;
AServer server = MockUtils.getServer(serverId);
AChannel aChannel = MockUtils.getTextChannel(server, channelId);
Long userEmbeddingUserInServerId = 5L;
AUserInAServer embeddingUser = MockUtils.getUserObject(userEmbeddingUserInServerId, server);
Long authorId = 7L;
AUserInAServer authorUser = MockUtils.getUserObject(authorId, server);
Long firstMessageId = 6L;
CachedMessage cachedMessage = CachedMessage.builder().serverId(serverId).channelId(channelId).messageId(firstMessageId).authorId(authorUser.getUserReference().getId()).build();
Member embeddingMember = Mockito.mock(Member.class);
Member author = Mockito.mock(Member.class);
Guild guild = Mockito.mock(Guild.class);
when(embeddingMessage.getMember()).thenReturn(embeddingMember);
when(textChannel.getIdLong()).thenReturn(channelId);
when(embeddingMessage.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(serverId);
when(embeddingMessage.getChannel()).thenReturn(textChannel);
when(userInServerManagementService.loadUser(embeddingMember)).thenReturn(embeddingUser);
when(userInServerManagementService.loadUser(userEmbeddingUserInServerId)).thenReturn(Optional.of(embeddingUser));
when(channelManagementService.loadChannel(channelId)).thenReturn(Optional.of(aChannel));
when(serverManagementService.loadOrCreate(serverId)).thenReturn(server);
when(botService.getMemberInServer(cachedMessage.getServerId(), cachedMessage.getAuthorId())).thenReturn(author);
when(botService.getTextChannelFromServer(cachedMessage.getServerId(), cachedMessage.getChannelId())).thenReturn(Optional.of(textChannel));
MessageToSend messageToSend = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq(MessageEmbedServiceBean.MESSAGE_EMBED_TEMPLATE), any(MessageEmbeddedModel.class))).thenReturn(messageToSend);
Message messageContainingEmbed = Mockito.mock(Message.class);
when(channelService.sendMessageToSendToChannel(messageToSend, textChannel)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(messageContainingEmbed)));
testUnit.embedLink(cachedMessage, textChannel, userEmbeddingUserInServerId, embeddingMessage);
verify(messageEmbedPostManagementService, times(1)).createMessageEmbed(cachedMessage, messageContainingEmbed, embeddingUser);
verify(messageService, times(1)).addReactionToMessage(MessageEmbedServiceBean.REMOVAL_EMOTE, cachedMessage.getServerId(), messageContainingEmbed);
}
@Test
public void testNotFoundUserEmbeddingLink() {
Long channelId = 6L;
Long serverId = 4L;
Long firstMessageId = 6L;
CachedMessage cachedMessage = CachedMessage.builder().serverId(serverId).channelId(channelId).messageId(firstMessageId).build();
Long userEmbeddingUserInServerId = 5L;
when(userInServerManagementService.loadUser(userEmbeddingUserInServerId)).thenReturn(Optional.empty());
testUnit.embedLink(cachedMessage, textChannel, userEmbeddingUserInServerId, embeddingMessage);
}
private void executeTestWithTwoLinks(String message) {
List<MessageEmbedLink> linksInMessage = testUnit.getLinksInMessage(message);
Assert.assertEquals(2, linksInMessage.size());
MessageEmbedLink firstLink = linksInMessage.get(0);
Assert.assertEquals(1, firstLink.getServerId().intValue());
Assert.assertEquals(2, firstLink.getChannelId().intValue());
Assert.assertEquals(3, firstLink.getMessageId().intValue());
MessageEmbedLink secondLink = linksInMessage.get(1);
Assert.assertEquals(2, secondLink.getServerId().intValue());
Assert.assertEquals(3, secondLink.getChannelId().intValue());
Assert.assertEquals(4, secondLink.getMessageId().intValue());
}
}

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

@@ -0,0 +1,213 @@
package dev.sheldan.abstracto.utility.service;
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.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.scheduling.service.SchedulerService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.exception.ReminderNotFoundException;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.ExecutedReminderModel;
import dev.sheldan.abstracto.utility.service.management.ReminderManagementService;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
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 org.quartz.JobDataMap;
import java.time.Duration;
import java.time.Instant;
import java.util.Date;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class RemindServiceBeanTest {
@InjectMocks
private RemindServiceBean testUnit;
@Mock
private ReminderManagementService reminderManagementService;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private TemplateService templateService;
@Mock
private SchedulerService schedulerService;
@Mock
private BotService botService;
@Mock
private ReminderService self;
@Mock
private ChannelService channelService;
@Mock
private Message message;
@Mock
private TextChannel channel;
@Before
public void setup() {
when(message.getIdLong()).thenReturn(5L);
when(channel.getIdLong()).thenReturn(5L);
when(message.getChannel()).thenReturn(channel);
}
@Test
public void createReminderWithScheduler() {
AServer server = MockUtils.getServer();
AUserInAServer user = MockUtils.getUserObject(4L, server);
AChannel aChannel = MockUtils.getTextChannel(server, 5L);
String remindText = "text";
Duration duration = Duration.ofSeconds(62);
when(channelManagementService.loadChannel(channel.getIdLong())).thenReturn(Optional.of(aChannel));
Long reminderId = 5L;
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(reminderId).build();
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);
verify(reminderManagementService, times(1)).saveReminder(createdReminder);
Assert.assertEquals(remindText, returnedReminder.getText());
Assert.assertEquals(createdReminder.getId(), returnedReminder.getId());
Assert.assertEquals(triggerKey, returnedReminder.getJobTriggerKey());
}
@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(Optional.of(aChannel));
Long reminderId = 5L;
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(reminderId).build();
Long messageId = 5L;
when(reminderManagementService.createReminder(any(AServerAChannelAUser.class), eq(remindText), any(Instant.class), eq(messageId))).thenReturn(createdReminder);
Reminder returnedReminder = testUnit.createReminderInForUser(user, remindText, duration, message);
verify(reminderManagementService, times(0)).saveReminder(createdReminder);
Assert.assertEquals(remindText, returnedReminder.getText());
Assert.assertEquals(createdReminder.getId(), returnedReminder.getId());
}
@Test
public void testExecuteReminder() {
AServer server = MockUtils.getServer();
AChannel aChannel = MockUtils.getTextChannel(server, 4L);
AUserInAServer remindedUser = MockUtils.getUserObject(5L, server);
Long reminderId = 5L;
Reminder remindedReminder = Reminder.builder().reminded(false).remindedUser(remindedUser).reminderDate(Instant.now()).targetDate(Instant.now()).server(server).channel(aChannel).id(reminderId).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.of(remindedReminder));
Guild guildMock = Mockito.mock(Guild.class);
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getTextChannelFromServer(server.getId(), aChannel.getId())).thenReturn(Optional.of(channel));
Member mockedMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(server.getId(), remindedUser.getUserReference().getId())).thenReturn(mockedMember);
MessageToSend messageToSend = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq("remind_reminder"), any(ExecutedReminderModel.class))).thenReturn(messageToSend);
testUnit.executeReminder(reminderId);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
verify(channelService, times(1)).sendMessageToSendToChannel(messageToSend, channel);
}
@Test
public void testExecuteReminderFromNotFoundChannel() {
AServer server = MockUtils.getServer();
AChannel aChannel = MockUtils.getTextChannel(server, 4L);
Long reminderId = 5L;
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).channel(aChannel).id(reminderId).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.of(remindedReminder));
Guild guildMock = Mockito.mock(Guild.class);
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getTextChannelFromServer(server.getId(), aChannel.getId())).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@Test
public void testExecuteReminderFromNotFoundGuild() {
AServer server = MockUtils.getServer();
Long reminderId = 5L;
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).id(reminderId).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.of(remindedReminder));
when(botService.getGuildById(server.getId())).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(Optional.of(remindedReminder));
testUnit.executeReminder(reminderId);
verify(botService, times(0)).getGuildById(anyLong());
}
@Test(expected = ReminderNotFoundException.class)
public void testExecuteIllegalReminderId() {
Long reminderId = 5L;
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
verify(botService, times(0)).getGuildById(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);
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);
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);
}
}

291
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/service/StarboardServiceBeanTest.java Normal file
View File

@@ -0,0 +1,291 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
import dev.sheldan.abstracto.core.exception.UserInServerNotFoundException;
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.AUserInAServer;
import dev.sheldan.abstracto.core.models.database.PostTarget;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.PostTargetService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.PostTargetManagement;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.config.StarboardConfig;
import dev.sheldan.abstracto.utility.config.posttargets.StarboardPostTarget;
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.StarStatsModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsPost;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarboardPostModel;
import dev.sheldan.abstracto.utility.service.management.StarboardPostManagementService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostReactorManagementService;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import net.dv8tion.jda.internal.entities.GuildImpl;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardServiceBeanTest {
@InjectMocks
private StarboardServiceBean testUnit;
@Mock
private BotService botService;
@Mock
private PostTargetService postTargetService;
@Mock
private TemplateService templateService;
@Mock
private ConfigService configService;
@Mock
private StarboardPostManagementService starboardPostManagementService;
@Mock
private StarboardConfig starboardConfig;
@Mock
private StarboardPostReactorManagementService starboardPostReactorManagementService;
@Mock
private PostTargetManagement postTargetManagement;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private EmoteService emoteService;
@Mock
private StarboardServiceBean self;
@Mock
private GuildImpl guild;
@Mock
private Message sendPost;
@Mock
private TextChannel mockedTextChannel;
@Captor
private ArgumentCaptor<AUserInAServer> userInAServerArgumentCaptor;
@Captor
private ArgumentCaptor<StarboardPostModel> starboardPostModelArgumentCaptor;
@Test
public void testCreateStarboardPost() {
AServer server = MockUtils.getServer();
List<AUserInAServer > userExceptAuthor = new ArrayList<>();
userExceptAuthor.add(MockUtils.getUserObject(2L, server));
userExceptAuthor.add(MockUtils.getUserObject(10L, server));
AUserInAServer userReacting = MockUtils.getUserObject(4L, server);
AUserInAServer starredUser = MockUtils.getUserObject(5L, server);
Long channelId = 10L;
CachedMessage message = CachedMessage
.builder()
.authorId(starredUser.getUserReference().getId())
.serverId(server.getId())
.channelId(channelId)
.build();
Member authorMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(message.getServerId(), message.getAuthorId())).thenReturn(authorMember);
when(botService.getTextChannelFromServer(server.getId(), channelId)).thenReturn(Optional.of(mockedTextChannel));
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guild));
MessageToSend postMessage = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq(StarboardServiceBean.STARBOARD_POST_TEMPLATE), starboardPostModelArgumentCaptor.capture())).thenReturn(postMessage);
AChannel channel = MockUtils.getTextChannel(server, channelId);
PostTarget postTarget = PostTarget.builder().channelReference(channel).build();
when(postTargetManagement.getPostTarget(StarboardPostTarget.STARBOARD.getKey(), server.getId())).thenReturn(postTarget);
List<CompletableFuture<Message>> futures = Arrays.asList(CompletableFuture.completedFuture(sendPost));
when(postTargetService.sendEmbedInPostTarget(postMessage, StarboardPostTarget.STARBOARD, server.getId())).thenReturn(futures);
when(starboardConfig.getLvl()).thenReturn(Arrays.asList(1,2));
when(configService.getLongValue("starLvl2", server.getId())).thenReturn(2L);
when(emoteService.getUsableEmoteOrDefault(server.getId(), "star2")).thenReturn("b");
testUnit.createStarboardPost(message, userExceptAuthor, userReacting, starredUser);
verify(self, times(1)).persistPost(eq(message), anyList(), eq(futures), eq(channelId), eq(starredUser.getUserInServerId()), eq(userReacting.getUserInServerId()));
List<StarboardPostModel> starboardPostModels = starboardPostModelArgumentCaptor.getAllValues();
Assert.assertEquals(1, starboardPostModels.size());
StarboardPostModel usedModel = starboardPostModels.get(0);
Assert.assertEquals("b", usedModel.getStarLevelEmote());
}
@Test
public void testPersistPost() {
AServer server = MockUtils.getServer();
AUserInAServer userReacting = MockUtils.getUserObject(4L, server);
AUserInAServer starredUser = MockUtils.getUserObject(5L, server);
Long channelId = 10L;
CachedMessage message = CachedMessage
.builder()
.authorId(starredUser.getUserReference().getId())
.serverId(server.getId())
.channelId(channelId)
.build();
Long secondStarrerUserId = 2L;
List<Long> userExceptAuthorIds = Arrays.asList(secondStarrerUserId, userReacting.getUserReference().getId());
List<CompletableFuture<Message>> futures = Arrays.asList(CompletableFuture.completedFuture(sendPost));
when(userInServerManagementService.loadUser(starredUser.getUserInServerId())).thenReturn(Optional.of(starredUser));
when(userInServerManagementService.loadUser(userReacting.getUserInServerId())).thenReturn(Optional.of(userReacting));
AChannel channel = MockUtils.getTextChannel(server, channelId);
when(channelManagementService.loadChannel(channelId)).thenReturn(Optional.of(channel));
StarboardPost post = StarboardPost.builder().build();
when(starboardPostManagementService.createStarboardPost(eq(message), eq(starredUser), any(AServerAChannelMessage.class))).thenReturn(post);
AUserInAServer secondStarrerUserObj = MockUtils.getUserObject(secondStarrerUserId, server);
when(userInServerManagementService.loadUser(secondStarrerUserId)).thenReturn(Optional.of(secondStarrerUserObj));
when(userInServerManagementService.loadUser(userReacting.getUserInServerId())).thenReturn(Optional.of(userReacting));
testUnit.persistPost(message, userExceptAuthorIds, futures, channelId, starredUser.getUserInServerId(), userReacting.getUserInServerId());
verify(starboardPostReactorManagementService, times(2)).addReactor(eq(post), userInAServerArgumentCaptor.capture());
List<AUserInAServer> addedReactors = userInAServerArgumentCaptor.getAllValues();
Assert.assertEquals(secondStarrerUserId, addedReactors.get(0).getUserInServerId());
Assert.assertEquals(userReacting.getUserInServerId(), addedReactors.get(1).getUserInServerId());
Assert.assertEquals(2, addedReactors.size());
}
@Test
public void testUpdateStarboardPost() {
AServer server = MockUtils.getServer();
Long postMessageId = 25L;
Long newPostId= 37L;
Long oldPostId = 36L;
AUserInAServer starredUser = MockUtils.getUserObject(5L, server);
Long channelId = 10L;
CachedMessage message = CachedMessage
.builder()
.authorId(starredUser.getUserReference().getId())
.serverId(server.getId())
.channelId(channelId)
.build();
Long starboardPostId = 47L;
StarboardPost post = StarboardPost.builder().postMessageId(postMessageId).starboardMessageId(oldPostId).id(starboardPostId).build();
MessageToSend postMessage = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq(StarboardServiceBean.STARBOARD_POST_TEMPLATE), starboardPostModelArgumentCaptor.capture())).thenReturn(postMessage);
when(postTargetService.editOrCreatedInPostTarget(oldPostId, postMessage, StarboardPostTarget.STARBOARD, server.getId())).thenReturn(Arrays.asList(CompletableFuture.completedFuture(sendPost)));
when(sendPost.getIdLong()).thenReturn(newPostId);
when(starboardPostManagementService.findByStarboardPostId(starboardPostId)).thenReturn(Optional.of(post));
List<AUserInAServer > userExceptAuthor = new ArrayList<>();
testUnit.updateStarboardPost(post, message, userExceptAuthor);
verify(postTargetService, times(1)).editOrCreatedInPostTarget(oldPostId, postMessage, StarboardPostTarget.STARBOARD, server.getId());
verify(starboardPostManagementService, times(1)).setStarboardPostMessageId(post, newPostId);
}
@Test
public void testDeleteStarboardMessagePost() {
AServer server = MockUtils.getServer();
AChannel channel = MockUtils.getTextChannel(server, 4L);
Long messageId = 4L;
StarboardPost post = StarboardPost
.builder()
.starboardChannel(channel)
.starboardMessageId(messageId)
.build();
testUnit.deleteStarboardMessagePost(post);
verify(botService, times(1)).deleteMessage(server.getId(), channel.getId(), messageId);
}
@Test(expected = UserInServerNotFoundException.class)
public void testPersistingOfNotFoundStarredUser() {
AServer server = MockUtils.getServer();
AUserInAServer userReacting = MockUtils.getUserObject(4L, server);
AUserInAServer starredUser = MockUtils.getUserObject(5L, server);
when(userInServerManagementService.loadUser(starredUser.getUserInServerId())).thenReturn(Optional.empty());
executeLoadErrorTest(server, userReacting, starredUser, 10L);
}
@Test(expected = ChannelNotFoundException.class)
public void testPersistingOfNotFoundChannel() {
AServer server = MockUtils.getServer();
AUserInAServer userReacting = MockUtils.getUserObject(4L, server);
AUserInAServer starredUser = MockUtils.getUserObject(5L, server);
when(userInServerManagementService.loadUser(starredUser.getUserInServerId())).thenReturn(Optional.of(starredUser));
Long channelId = 10L;
when(channelManagementService.loadChannel(channelId)).thenReturn(Optional.empty());
executeLoadErrorTest(server, userReacting, starredUser, channelId);
}
@Test
public void testRetrieveStarStats() {
AServer server = MockUtils.getServer();
Integer limit = 3;
AChannel channel = MockUtils.getTextChannel(server, 4L);
Long firstPostMessageId = 50L;
Long secondPostMessageId = 51L;
StarboardPostReaction reaction = StarboardPostReaction.builder().build();
StarboardPost post1 = StarboardPost.builder().starboardChannel(channel).postMessageId(firstPostMessageId).reactions(Arrays.asList(reaction)).build();
StarboardPost post2 = StarboardPost.builder().starboardChannel(channel).postMessageId(secondPostMessageId).reactions(new ArrayList<>()).build();
List<StarboardPost> topPosts = Arrays.asList(post1, post2);
when(starboardPostManagementService.retrieveTopPosts(server.getId(), limit)).thenReturn(topPosts);
StarStatsUser statsUser = StarStatsUser.builder().build();
StarStatsUser statsUser2 = StarStatsUser.builder().build();
List<StarStatsUser> topGiver = Arrays.asList(statsUser, statsUser2);
when(starboardPostReactorManagementService.retrieveTopStarGiver(server.getId(), limit)).thenReturn(topGiver);
when(starboardPostReactorManagementService.retrieveTopStarReceiver(server.getId(), limit)).thenReturn(topGiver);
when(starboardPostManagementService.getPostCount(server.getId())).thenReturn(50);
when(starboardPostReactorManagementService.getStarCount(server.getId())).thenReturn(500);
when(emoteService.getUsableEmoteOrDefault(server.getId(), "starboardBadge1")).thenReturn("1");
when(emoteService.getUsableEmoteOrDefault(server.getId(), "starboardBadge2")).thenReturn("2");
when(emoteService.getUsableEmoteOrDefault(server.getId(), "starboardBadge3")).thenReturn("3");
StarStatsModel model = testUnit.retrieveStarStats(server.getId());
List<String> badgeEmotes = model.getBadgeEmotes();
Assert.assertEquals(limit.intValue(), badgeEmotes.size());
Assert.assertEquals("1", badgeEmotes.get(0));
Assert.assertEquals("2", badgeEmotes.get(1));
Assert.assertEquals("3", badgeEmotes.get(2));
Assert.assertEquals(500, model.getTotalStars().intValue());
Assert.assertEquals(50, model.getStarredMessages().intValue());
StarStatsPost topPost = model.getTopPosts().get(0);
Assert.assertEquals(server.getId(), topPost.getServerId());
Assert.assertEquals(channel.getId(), topPost.getChannelId());
Assert.assertEquals(firstPostMessageId, topPost.getMessageId());
Assert.assertEquals(1, topPost.getStarCount().intValue());
StarStatsPost secondTopPost = model.getTopPosts().get(1);
Assert.assertEquals(server.getId(), secondTopPost.getServerId());
Assert.assertEquals(channel.getId(), secondTopPost.getChannelId());
Assert.assertEquals(secondPostMessageId, secondTopPost.getMessageId());
Assert.assertEquals(0, secondTopPost.getStarCount().intValue());
}
private void executeLoadErrorTest(AServer server, AUserInAServer userReacting, AUserInAServer starredUser, Long channelId) {
CachedMessage message = CachedMessage
.builder()
.authorId(starredUser.getUserReference().getId())
.serverId(server.getId())
.channelId(channelId)
.build();
Long secondStarrerUserId = 2L;
List<Long> userExceptAuthorIds = Arrays.asList(secondStarrerUserId, userReacting.getUserReference().getId());
List<CompletableFuture<Message>> futures = Arrays.asList(CompletableFuture.completedFuture(sendPost));
testUnit.persistPost(message, userExceptAuthorIds, futures, channelId, starredUser.getUserInServerId(), userReacting.getUserInServerId());
}
}

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

@@ -0,0 +1,264 @@
package dev.sheldan.abstracto.utility.service;
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.BotService;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.PostTargetService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.config.posttargets.SuggestionPostTarget;
import dev.sheldan.abstracto.utility.exception.SuggestionNotFoundException;
import dev.sheldan.abstracto.utility.exception.SuggestionUpdateException;
import dev.sheldan.abstracto.utility.models.SuggestionState;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.management.SuggestionManagementService;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.requests.RestAction;
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;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class SuggestionServiceBeanTest {
public static final String CLOSING_TEXT = "accepted";
@InjectMocks
private SuggestionServiceBean testUnit;
@Mock
private SuggestionManagementService suggestionManagementService;
@Mock
private PostTargetService postTargetService;
@Mock
private TemplateService templateService;
@Mock
private BotService botService;
@Mock
private MessageService messageService;
@Mock
private SuggestionServiceBean self;
@Mock
private Member suggestionCreator;
@Mock
private Guild guild;
@Mock
private TextChannel textChannel;
@Test
public void testCreateSuggestion() {
String suggestionText = "text";
AServer server = MockUtils.getServer();
SuggestionLog log = SuggestionLog.builder().build();
Long suggestionId = 5L;
Suggestion createdSuggestion = Suggestion.builder().id(suggestionId).build();
when(suggestionCreator.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(server.getId());
when(suggestionManagementService.createSuggestion(suggestionCreator, suggestionText)).thenReturn(createdSuggestion);
MessageToSend messageToSend = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class))).thenReturn(messageToSend);
Message suggestionMessage = Mockito.mock(Message.class);
List<CompletableFuture<Message>> postingFutures = Arrays.asList(CompletableFuture.completedFuture(suggestionMessage));
when(postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, server.getId())).thenReturn(postingFutures);
when(suggestionManagementService.getSuggestion(suggestionId)).thenReturn(Optional.of(createdSuggestion));
testUnit.createSuggestion(suggestionCreator, suggestionText, log);
verify(suggestionManagementService, times(1)).setPostedMessage(createdSuggestion, suggestionMessage);
verify( messageService, times(1)).addReactionToMessage(SuggestionServiceBean.SUGGESTION_YES_EMOTE, server.getId(), suggestionMessage);
verify( messageService, times(1)).addReactionToMessage(SuggestionServiceBean.SUGGESTION_NO_EMOTE, server.getId(), suggestionMessage);
}
@Test
public void testAcceptExistingSuggestion() {
Member suggesterMember = Mockito.mock(Member.class);
executeAcceptWithMember(suggesterMember);
}
@Test(expected = SuggestionNotFoundException.class)
public void testAcceptNotExistingSuggestion() {
Long suggestionId = 5L;
when(suggestionManagementService.getSuggestion(suggestionId)).thenReturn(Optional.empty());
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test
public void testAcceptSuggestionWithMemberLeavingGuild() {
executeAcceptWithMember(null);
}
@Test
public void testAcceptSuggestionInNoTextChannel() {
Long suggestionId = 5L;
setupForNoTextChannel(suggestionId);
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
}
private void setupForNoTextChannel(Long suggestionId) {
AServer server = MockUtils.getServer();
Long channelId = 5L;
Long messageId = 7L;
AChannel channel = MockUtils.getTextChannel(server, channelId);
AUserInAServer suggester = MockUtils.getUserObject(4L, server);
Suggestion suggestionToAccept = Suggestion
.builder()
.channel(channel)
.server(server)
.id(suggestionId)
.suggester(suggester)
.messageId(messageId)
.build();
when(suggestionManagementService.getSuggestion(suggestionId)).thenReturn(Optional.of(suggestionToAccept));
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guild));
Member suggesterMember = Mockito.mock(Member.class);
when(guild.getMemberById(suggester.getUserReference().getId())).thenReturn(suggesterMember);
when(guild.getTextChannelById(channelId)).thenReturn(null);
}
@Test
public void testAcceptSuggestionInNoGuild() {
Long suggestionId = 5L;
setupForNoGuild(suggestionId);
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test(expected = SuggestionUpdateException.class)
public void testUpdateSuggestionTextWithoutEmbed() {
SuggestionLog log = SuggestionLog.builder().build();
Message suggestionMessage = Mockito.mock(Message.class);
testUnit.updateSuggestionMessageText(CLOSING_TEXT, log, suggestionMessage);
}
@Test
public void testUpdateSuggestionMessageWithEmbed() {
AServer server = MockUtils.getServer();
SuggestionLog log = SuggestionLog.builder().server(server).build();
MessageEmbed embed = Mockito.mock(MessageEmbed.class);
when(embed.getDescription()).thenReturn("description");
Message suggestionMessage = Mockito.mock(Message.class);
when(suggestionMessage.getEmbeds()).thenReturn(Arrays.asList(embed));
MessageToSend updatedMessage = MessageToSend.builder().build();
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.getId());
}
@Test
public void testRejectExistingSuggestion() {
Member suggesterMember = Mockito.mock(Member.class);
executeRejectWithMember(suggesterMember);
}
@Test(expected = SuggestionNotFoundException.class)
public void testRejectNotExistingSuggestion() {
Long suggestionId = 5L;
when(suggestionManagementService.getSuggestion(suggestionId)).thenReturn(Optional.empty());
testUnit.rejectSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test
public void testRejectSuggestionWithMemberLeavingGuild() {
executeRejectWithMember(null);
}
@Test
public void testRejectSuggestionInNoTextChannel() {
Long suggestionId = setupForNoTextChannel();
testUnit.rejectSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test
public void testRejectSuggestionInNoGuild() {
Long suggestionId = 5L;
setupForNoGuild(suggestionId);
testUnit.rejectSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
}
private Long setupForNoTextChannel() {
Long suggestionId = 5L;
setupForNoTextChannel(suggestionId);
return suggestionId;
}
private Long setupForNoGuild(Long suggestionId) {
AServer server = MockUtils.getServer();
Long channelId = 5L;
AChannel channel = MockUtils.getTextChannel(server, channelId);
Suggestion suggestionToAccept = Suggestion
.builder()
.server(server)
.id(suggestionId)
.channel(channel)
.build();
when(suggestionManagementService.getSuggestion(suggestionId)).thenReturn(Optional.of(suggestionToAccept));
when(botService.getGuildById(server.getId())).thenReturn(Optional.empty());
return suggestionId;
}
private void executeAcceptWithMember(Member suggesterMember) {
Long suggestionId = 5L;
Long channelId = 5L;
Long messageId = 7L;
SuggestionLog logParameter = SuggestionLog.builder().build();
Suggestion suggestionToAccept = setupClosing(suggesterMember, suggestionId, channelId, messageId);
RestAction<Message> retrievalAction = Mockito.mock(RestAction.class);
when(textChannel.retrieveMessageById(messageId)).thenReturn(retrievalAction);
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, logParameter);
verify(suggestionManagementService, times(1)).setSuggestionState(suggestionToAccept, SuggestionState.ACCEPTED);
verify(retrievalAction, times(1)).queue(any(Consumer.class));
}
private void executeRejectWithMember(Member suggesterMember) {
Long suggestionId = 5L;
Long channelId = 5L;
Long messageId = 7L;
SuggestionLog logParameter = SuggestionLog.builder().build();
Suggestion suggestionToAccept = setupClosing(suggesterMember, suggestionId, channelId, messageId);
RestAction<Message> retrievalAction = Mockito.mock(RestAction.class);
when(textChannel.retrieveMessageById(messageId)).thenReturn(retrievalAction);
testUnit.rejectSuggestion(suggestionId, CLOSING_TEXT, logParameter);
verify(suggestionManagementService, times(1)).setSuggestionState(suggestionToAccept, SuggestionState.REJECTED);
verify(retrievalAction, times(1)).queue(any(Consumer.class));
}
private Suggestion setupClosing(Member suggesterMember, Long suggestionId, Long channelId, Long messageId) {
AServer server = MockUtils.getServer();
AChannel channel = MockUtils.getTextChannel(server, channelId);
AUserInAServer suggester = MockUtils.getUserObject(4L, server);
Suggestion suggestionToAccept = Suggestion
.builder()
.channel(channel)
.server(server)
.id(suggestionId)
.suggester(suggester)
.messageId(messageId)
.build();
when(suggestionManagementService.getSuggestion(suggestionId)).thenReturn(Optional.of(suggestionToAccept));
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guild));
when(guild.getTextChannelById(channelId)).thenReturn(textChannel);
when(guild.getMemberById(suggester.getUserReference().getId())).thenReturn(suggesterMember);
return suggestionToAccept;
}
}

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

@@ -0,0 +1,129 @@
package dev.sheldan.abstracto.utility.service.management;
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.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.exception.CrossServerEmbedException;
import dev.sheldan.abstracto.utility.models.database.EmbeddedMessage;
import dev.sheldan.abstracto.utility.repository.EmbeddedMessageRepository;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class MessageEmbedPostManagementServiceBeanTest {
@InjectMocks
private MessageEmbedPostManagementServiceBean testUnit;
@Mock
private EmbeddedMessageRepository embeddedMessageRepository;
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private ServerManagementService serverManagementService;
@Mock
private ChannelManagementService channelManagementService;
@Captor
private ArgumentCaptor<EmbeddedMessage> messageArgumentCaptor;
@Test
public void testCreateCorrectEmbed(){
AServer server = MockUtils.getServer();
AUserInAServer embeddingUser = MockUtils.getUserObject(5L, server);
AUserInAServer embeddedUser = MockUtils.getUserObject(7L, server);
AChannel channel = MockUtils.getTextChannel(server, 8L);
when(serverManagementService.loadOrCreate(server.getId())).thenReturn(server);
when(channelManagementService.loadChannel(channel.getId())).thenReturn(Optional.of(channel));
Long embeddedMessageId = 5L;
Long embeddingMessageId = 7L;
CachedMessage cachedMessage = CachedMessage
.builder()
.messageId(embeddedMessageId)
.channelId(channel.getId())
.serverId(server.getId())
.authorId(embeddedUser.getUserReference().getId())
.build();
Message message = Mockito.mock(Message.class);
Guild guild = Mockito.mock(Guild.class);
MessageChannel embeddedChannel = Mockito.mock(MessageChannel.class);
when(message.getChannel()).thenReturn(embeddedChannel);
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(server.getId());
when(message.getIdLong()).thenReturn(embeddingMessageId);
when(embeddedChannel.getIdLong()).thenReturn(channel.getId());
when(userInServerManagementService.loadUser(server.getId(), embeddedUser.getUserReference().getId())).thenReturn(embeddedUser);
testUnit.createMessageEmbed(cachedMessage, message, embeddingUser);
verify(embeddedMessageRepository, times(1)).save(messageArgumentCaptor.capture());
EmbeddedMessage savedMessage = messageArgumentCaptor.getValue();
Assert.assertEquals(embeddedMessageId, savedMessage.getEmbeddedMessageId());
Assert.assertEquals(channel, savedMessage.getEmbeddedChannel());
Assert.assertEquals(channel, savedMessage.getEmbeddingChannel());
Assert.assertEquals(embeddedUser, savedMessage.getEmbeddedUser());
Assert.assertEquals(embeddingUser, savedMessage.getEmbeddingUser());
Assert.assertEquals(server, savedMessage.getEmbeddedServer());
Assert.assertEquals(server, savedMessage.getEmbeddingServer());
Assert.assertEquals(embeddingMessageId, savedMessage.getEmbeddingMessageId());
}
@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();
Message message = Mockito.mock(Message.class);
Guild guild = Mockito.mock(Guild.class);
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(embeddingServer.getId());
testUnit.createMessageEmbed(cachedMessage, message, embeddingUser);
}
@Test
public void testDeleteEmbeddedMessage() {
EmbeddedMessage message = Mockito.mock(EmbeddedMessage.class);
testUnit.deleteEmbeddedMessage(message);
verify(embeddedMessageRepository, times(1)).delete(message);
}
@Test
public void testFindEmbeddedMessageByMessageIdSuccessful() {
Long id = 5L;
EmbeddedMessage message = Mockito.mock(EmbeddedMessage.class);
when(embeddedMessageRepository.findByEmbeddingMessageId(id)).thenReturn(message);
Optional<EmbeddedMessage> embeddedPostByMessageId = testUnit.findEmbeddedPostByMessageId(id);
Assert.assertTrue(embeddedPostByMessageId.isPresent());
}
@Test
public void testFindEmbeddedMessageByMessageIdFailing() {
Long id = 5L;
when(embeddedMessageRepository.findByEmbeddingMessageId(id)).thenReturn(null);
Optional<EmbeddedMessage> embeddedPostByMessageId = testUnit.findEmbeddedPostByMessageId(id);
Assert.assertFalse(embeddedPostByMessageId.isPresent());
}
}

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

@@ -0,0 +1,132 @@
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.AUserInAServer;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.repository.ReminderRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class ReminderManagementServiceBeanTest {
@InjectMocks
private ReminderManagementServiceBean testUnit;
@Mock
private ReminderRepository reminderRepository;
@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();
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);
}
@Test
public void testSetReminded() {
Reminder reminder = Reminder.builder().build();
testUnit.setReminded(reminder);
reminder.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);
for (int i = 0; i < reminders.size(); i++) {
Reminder reference = reminders.get(i);
Reminder returned = activeRemindersForUser.get(0);
Assert.assertEquals(reference, returned);
}
Assert.assertEquals(reminders.size(), activeRemindersForUser.size());
}
@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);
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);
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.loadReminder(reminderId);
Assert.assertTrue(returned.isPresent());
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminderToLoad, returnedReminder));
}
@Test
public void testLoadingReminderNotFound() {
Long reminderId = 5L;
when(reminderRepository.findById(reminderId)).thenReturn(Optional.empty());
Optional<Reminder> returned = testUnit.loadReminder(reminderId);
Assert.assertFalse(returned.isPresent());
}
}

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

@@ -0,0 +1,222 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
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.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.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;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardPostManagementServiceBeanTest {
@InjectMocks
private StarboardPostManagementServiceBean testUnit;
@Mock
private StarboardPostRepository repository;
@Mock
private ChannelManagementService channelManagementService;
@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(Optional.ofNullable(sourceChannel));
StarboardPost createdStarboardPost = testUnit.createStarboardPost(starredMessage, userInAServer, 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(starboardPostId, createdStarboardPost.getStarboardMessageId());
Assert.assertEquals(starredMessageId, createdStarboardPost.getPostMessageId());
Assert.assertEquals(userInAServer.getUserInServerId(), createdStarboardPost.getAuthor().getUserInServerId());
Assert.assertEquals(sourceChannel.getId(), createdStarboardPost.getSourceChanel().getId());
Assert.assertFalse(createdStarboardPost.isIgnored());
}
@Test(expected = ChannelNotFoundException.class)
public void testCreateStarboardPostForNonExistingChannel() {
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(Optional.empty());
testUnit.createStarboardPost(starredMessage, userInAServer, postInStarboard);
}
@Test
public void setStarboardMessageId(){
StarboardPost post = StarboardPost
.builder()
.build();
Long messageId = 6L;
testUnit.setStarboardPostMessageId(post, messageId);
Assert.assertEquals(messageId, post.getStarboardMessageId());
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();
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2, starboardPost3);
when(repository.findByStarboardChannelServerId(server.getId())).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(server.getId(), count);
Assert.assertEquals(count.intValue(), topPosts.size());
StarboardPost topMostPost = topPosts.get(0);
StarboardPost secondTop = topPosts.get(1);
Assert.assertEquals(starboardPost1, topPosts.get(0));
Assert.assertEquals(starboardPost2, secondTop);
Assert.assertTrue(topMostPost.getReactions().size() > secondTop.getReactions().size());
}
@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();
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2, starboardPost3);
when(repository.findByStarboardChannelServerId(server.getId())).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(server.getId(), count);
StarboardPost topMostPost = topPosts.get(0);
StarboardPost secondTop = topPosts.get(1);
StarboardPost thirdTopMostPost = topPosts.get(2);
Assert.assertEquals(3, topPosts.size());
Assert.assertEquals(starboardPost1, topPosts.get(0));
Assert.assertEquals(starboardPost2, secondTop);
Assert.assertEquals(starboardPost3, thirdTopMostPost);
Assert.assertTrue(topMostPost.getReactions().size() > secondTop.getReactions().size());
Assert.assertTrue(secondTop.getReactions().size() > thirdTopMostPost.getReactions().size());
}
@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());
verify(repository, times(1)).delete(any(StarboardPost.class));
}
@Test
public void testSetStarboardPostIgnored() {
Long messageId = 5L;
Boolean ignoredValue = true;
StarboardPost post = StarboardPost.builder().build();
when(repository.findByStarboardMessageId(messageId)).thenReturn(post);
testUnit.setStarboardPostIgnored(messageId, ignoredValue);
Assert.assertTrue(post.isIgnored());
verify(repository, times(1)).save(post);
}
@Test
public void testIsStarboardPost() {
Long starboardPostId = 5L;
when(repository.existsByStarboardMessageId(starboardPostId)).thenReturn(true);
boolean starboardPost = testUnit.isStarboardPost(starboardPostId);
Assert.assertTrue(starboardPost);
}
@Test
public void testFindByMessageId() {
Long messageId = 5L;
StarboardPost post = StarboardPost.builder().build();
when(repository.findByPostMessageId(messageId)).thenReturn(post);
Optional<StarboardPost> postOptional = testUnit.findByMessageId(messageId);
Assert.assertTrue(postOptional.isPresent());
postOptional.ifPresent(starboardPost -> Assert.assertEquals(starboardPost, post));
}
@Test
public void testFindByMessageIdMissing() {
Long messageId = 5L;
when(repository.findByPostMessageId(messageId)).thenReturn(null);
Optional<StarboardPost> postOptional = testUnit.findByMessageId(messageId);
Assert.assertFalse(postOptional.isPresent());
}
@Test
public void testFindByStarboardPostId() {
Long postId = 5L;
StarboardPost post = StarboardPost.builder().build();
when(repository.findByStarboardMessageId(postId)).thenReturn(post);
Optional<StarboardPost> postOptional = testUnit.findByStarboardPostId(postId);
Assert.assertTrue(postOptional.isPresent());
postOptional.ifPresent(starboardPost -> Assert.assertEquals(starboardPost, post));
}
@Test
public void testFindByStarboardPostIdMissing() {
Long postId = 5L;
when(repository.findByStarboardMessageId(postId)).thenReturn(null);
Optional<StarboardPost> postOptional = testUnit.findByStarboardPostId(postId);
Assert.assertFalse(postOptional.isPresent());
}
@Test
public void testRetrievePostCount() {
AServer server = MockUtils.getServer();
StarboardPost starboardPost1 = StarboardPost.builder().build();
StarboardPost starboardPost2 = StarboardPost.builder().build();
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2);
when(repository.findByStarboardChannelServerId(server.getId())).thenReturn(posts);
Integer retrievedPostCount = testUnit.getPostCount(server.getId());
Assert.assertEquals(posts.size(), retrievedPostCount.intValue());
}
}

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

@@ -0,0 +1,157 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.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;
import dev.sheldan.abstracto.utility.repository.StarStatsUserResult;
import dev.sheldan.abstracto.utility.repository.StarboardPostReactionRepository;
import dev.sheldan.abstracto.utility.repository.converter.StarStatsUserConverter;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardPostReactorManagementServiceBeanTest {
@InjectMocks
private StarboardPostReactorManagementServiceBean testUnit;
@Mock
private StarboardPostReactionRepository repository;
@Mock
private StarStatsUserConverter converter;
@Captor
private ArgumentCaptor<StarboardPostReaction> reactorCaptor;
@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);
verify(repository, times(1)).save(reactorCaptor.capture());
StarboardPostReaction reaction = reactorCaptor.getValue();
Assert.assertEquals(post, reaction.getStarboardPost());
Assert.assertEquals(userInAServer, 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);
}
@Test
public void testRemoveReactors() {
StarboardPost post = StarboardPost.builder().build();
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);
Assert.assertEquals(stars, starCount);
}
@Test
public void testRetrieveTopStarGiverAllAreAvailable() {
testTopStarGiver(2, 2);
}
@Test
public void testRetrieveTopStarGiverNotAllAreAvailable() {
testTopStarGiver(2, 3);
}
@Test
public void testRetrieveTopStarGiverMoreAreAvailable() {
testTopStarGiver(1, 1);
}
@Test
public void testRetrieveTopStarReceiverAllAreAvailable() {
testTopStarReceiver(2, 2);
}
@Test
public void testRetrieveTopStarReceiverNotAllAreAvailable() {
testTopStarReceiver(2, 3);
}
@Test
public void testRetrieveTopStarReceiverMoreAreAvailable() {
testTopStarReceiver(1, 1);
}
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<StarStatsUser> starStatsUsers = testUnit.retrieveTopStarReceiver(serverId, amountToRetrieve);
Assert.assertEquals(expectedAmount, starStatsUsers.size());
Assert.assertEquals(user1, starStatsUsers.get(0));
if(amountToRetrieve > 1) {
Assert.assertEquals(user2, starStatsUsers.get(1));
}
}
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<StarStatsUser> starStatsUsers = testUnit.retrieveTopStarGiver(serverId, amountToRetrieve);
Assert.assertEquals(expectedAmount, starStatsUsers.size());
Assert.assertEquals(user1, starStatsUsers.get(0));
if(amountToRetrieve > 1) {
Assert.assertEquals(user2, starStatsUsers.get(1));
}
}
private void setupStarStatsGiverResult(Integer amountToRetrieve, Long serverId, StarStatsUser user1, StarStatsUser user2) {
StarStatsUserResult result1 = Mockito.mock(StarStatsUserResult.class);
StarStatsUserResult result2 = Mockito.mock(StarStatsUserResult.class);
List<StarStatsUserResult> results = Arrays.asList(result1, result2);
when(repository.findTopStarGiverInServer(serverId, amountToRetrieve)).thenReturn(results);
List<StarStatsUser> statsUser = new ArrayList<>();
statsUser.add(user1);
if (amountToRetrieve > 1) {
statsUser.add(user2);
}
when(converter.convertToStarStatsUser(results, serverId)).thenReturn(statsUser);
}
private void setupStarStatsReceiverResult(Integer amountToRetrieve, Long serverId, StarStatsUser user1, StarStatsUser user2) {
StarStatsUserResult result1 = Mockito.mock(StarStatsUserResult.class);
StarStatsUserResult result2 = Mockito.mock(StarStatsUserResult.class);
List<StarStatsUserResult> results = Arrays.asList(result1, result2);
when(repository.retrieveTopStarReceiverInServer(serverId, amountToRetrieve)).thenReturn(results);
List<StarStatsUser> statsUser = new ArrayList<>();
statsUser.add(user1);
if (amountToRetrieve > 1) {
statsUser.add(user2);
}
when(converter.convertToStarStatsUser(results, serverId)).thenReturn(statsUser);
}
}

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

@@ -0,0 +1,129 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
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.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.models.SuggestionState;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.repository.SuggestionRepository;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class SuggestionManagementServiceBeanTest {
@InjectMocks
private SuggestionManagementServiceBean testUnit;
@Mock
private SuggestionRepository suggestionRepository;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private ServerManagementService serverManagementService;
@Test
public void testCreateSuggestionViaUser() {
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
String text = "text";
Suggestion createdSuggestion = testUnit.createSuggestion(userInAServer, text);
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());
}
@Test
public void testCreateSuggestionViaMember() {
Member member = Mockito.mock(Member.class);
AServer server = MockUtils.getServer();
AUserInAServer userInAServer = MockUtils.getUserObject(5L, server);
String text = "text";
when(userInServerManagementService.loadUser(member)).thenReturn(userInAServer);
Suggestion createdSuggestion = testUnit.createSuggestion(member, text);
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());
}
@Test
public void testGetSuggestion() {
Long suggestionId = 5L;
Suggestion foundSuggestion = Suggestion.builder().id(suggestionId).build();
when(suggestionRepository.findById(suggestionId)).thenReturn(Optional.of(foundSuggestion));
Optional<Suggestion> suggestionOptional = testUnit.getSuggestion(suggestionId);
Assert.assertTrue(suggestionOptional.isPresent());
suggestionOptional.ifPresent(suggestion -> Assert.assertEquals(suggestionId, suggestion.getId()));
}
@Test
public void testGetSuggestionNotFound() {
Long suggestionId = 5L;
when(suggestionRepository.findById(suggestionId)).thenReturn(Optional.empty());
Optional<Suggestion> suggestionOptional = testUnit.getSuggestion(suggestionId);
Assert.assertFalse(suggestionOptional.isPresent());
}
@Test
public void testSetPostedMessage() {
Long messageId = 5L;
Long channelId = 6L;
Suggestion suggestion = Suggestion.builder().build();
Message message = Mockito.mock(Message.class);
MessageChannel channel = Mockito.mock(MessageChannel.class);
when(message.getChannel()).thenReturn(channel);
when(channel.getIdLong()).thenReturn(channelId);
when(message.getIdLong()).thenReturn(messageId);
AChannel aChannel = AChannel.builder().id(channelId).build();
when(channelManagementService.loadChannel(channelId)).thenReturn(Optional.of(aChannel));
testUnit.setPostedMessage(suggestion, message);
Assert.assertEquals(messageId, suggestion.getMessageId());
Assert.assertEquals(channelId, suggestion.getChannel().getId());
verify(suggestionRepository, times(1)).save(suggestion);
}
@Test(expected = ChannelNotFoundException.class)
public void testSetPostedMessageChannelNotFound() {
Long channelId = 6L;
AServer server = MockUtils.getServer();
Suggestion suggestion = Suggestion.builder().server(server).build();
Message message = Mockito.mock(Message.class);
MessageChannel channel = Mockito.mock(MessageChannel.class);
when(message.getChannel()).thenReturn(channel);
when(channel.getIdLong()).thenReturn(channelId);
when(channelManagementService.loadChannel(channelId)).thenReturn(Optional.empty());
testUnit.setPostedMessage(suggestion, message);
}
@Test
public void setSuggestionState() {
Suggestion suggestion = Suggestion.builder().build();
testUnit.setSuggestionState(suggestion, SuggestionState.ACCEPTED);
Assert.assertEquals(suggestion.getState(), SuggestionState.ACCEPTED);
verify(suggestionRepository, times(1)).save(suggestion);
}
}

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

@@ -0,0 +1,51 @@
package dev.sheldan.abstracto.utility.validator;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.FeatureValidatorService;
import dev.sheldan.abstracto.test.MockUtils;
import dev.sheldan.abstracto.utility.config.StarboardConfig;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class StarboardFeatureValidatorServiceTest {
@InjectMocks
private StarboardFeatureValidatorService testUnit;
@Mock
private StarboardConfig starboardConfig;
@Mock
private FeatureValidatorService featureValidatorService;
@Captor
private ArgumentCaptor<String> configKeyCaptor;
@Test
public void testStarboardFeatureConfig() {
List<Integer> definedLevels = Arrays.asList(1, 2, 3);
when(starboardConfig.getLvl()).thenReturn(definedLevels);
AServer server = MockUtils.getServer();
testUnit.featureIsSetup(null, server, null);
verify(featureValidatorService, times(definedLevels.size())).checkSystemConfig(configKeyCaptor.capture(), eq(server), any());
List<String> allValues = configKeyCaptor.getAllValues();
for (int i = 0; i < allValues.size(); i++) {
String key = allValues.get(i);
Assert.assertEquals("starLvl"+ ( i + 1 ), key);
}
Assert.assertEquals(definedLevels.size(), allValues.size());
}
}

9
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/exception/CrossServerEmbedException.java Normal file
View File

@@ -0,0 +1,9 @@
package dev.sheldan.abstracto.utility.exception;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
public class CrossServerEmbedException extends AbstractoRunTimeException {
public CrossServerEmbedException(String message) {
super(message);
}
}

9
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/exception/SuggestionUpdateException.java Normal file
View File

@@ -0,0 +1,9 @@
package dev.sheldan.abstracto.utility.exception;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
public class SuggestionUpdateException extends AbstractoRunTimeException {
public SuggestionUpdateException(String message) {
super(message);
}
}

2
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/models/template/commands/SuggestionLog.java
View File

@@ -1,6 +1,7 @@
package dev.sheldan.abstracto.utility.models.template.commands;
import dev.sheldan.abstracto.core.models.context.UserInitiatedServerContext;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import lombok.Getter;
import lombok.Setter;
@@ -13,6 +14,7 @@ import net.dv8tion.jda.api.entities.Member;
public class SuggestionLog extends UserInitiatedServerContext {
private Suggestion suggestion;
private Member suggester;
private AUserInAServer suggesterUser;
private String text;
private String reason;
private Long originalMessageId;

13
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/models/template/commands/starboard/StarStatsPost.java
View File

@@ -1,8 +1,6 @@
package dev.sheldan.abstracto.utility.models.template.commands.starboard;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.utils.MessageUtils;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
@@ -19,15 +17,4 @@ public class StarStatsPost {
public String getMessageUrl() {
return MessageUtils.buildMessageUrl(serverId ,channelId, messageId);
}
public static StarStatsPost fromStarboardPost(StarboardPost starboardPost) {
AChannel channel = starboardPost.getStarboardChannel();
return StarStatsPost
.builder()
.serverId(channel.getServer().getId())
.channelId(channel.getId())
.messageId(starboardPost.getPostMessageId())
.starCount(starboardPost.getReactions().size())
.build();
}
}

5
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/service/ReminderService.java
View File

@@ -1,12 +1,13 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.utility.models.template.commands.reminder.ReminderModel;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import net.dv8tion.jda.api.entities.Message;
import java.time.Duration;
public interface ReminderService {
void createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, ReminderModel reminderModel);
Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Message message);
void executeReminder(Long reminderId);
void unRemind(Long reminderId, AUserInAServer userInAServer);
}

2
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/service/StarboardService.java
View File

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsPost;
import java.util.List;
@@ -12,4 +13,5 @@ public interface StarboardService {
void updateStarboardPost(StarboardPost post, CachedMessage message, List<AUserInAServer> userExceptAuthor);
void deleteStarboardMessagePost(StarboardPost message);
StarStatsModel retrieveStarStats(Long serverId);
StarStatsPost fromStarboardPost(StarboardPost starboardPost);
}

1
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/service/SuggestionService.java
View File

@@ -7,5 +7,4 @@ public interface SuggestionService {
void createSuggestion(Member member, String text, SuggestionLog log);
void acceptSuggestion(Long suggestionId, String text, SuggestionLog log);
void rejectSuggestion(Long suggestionId, String text, SuggestionLog log);
void validateSetup(Long serverId);
}

1
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/service/management/MessageEmbedPostManagementService.java
View File

@@ -11,5 +11,4 @@ public interface MessageEmbedPostManagementService {
void createMessageEmbed(CachedMessage embeddedMessage, Message messageContainingEmbed, AUserInAServer cause);
Optional<EmbeddedMessage> findEmbeddedPostByMessageId(Long messageId);
void deleteEmbeddedMessage(EmbeddedMessage embeddedMessage);
void deleteEmbeddedMessageTransactional(EmbeddedMessage embeddedMessage);
}

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

@@ -14,5 +14,5 @@ public interface ReminderManagementService {
void setReminded(Reminder reminder);
Reminder saveReminder(Reminder reminder);
List<Reminder> getActiveRemindersForUser(AUserInAServer aUserInAServer);
Reminder getReminderByAndByUserNotReminded(AUserInAServer aUserInAServer, Long reminderId);
Optional<Reminder> getReminderByAndByUserNotReminded(AUserInAServer aUserInAServer, Long reminderId);
}

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

@@ -9,7 +9,7 @@ import java.util.List;
import java.util.Optional;
public interface StarboardPostManagementService {
StarboardPost createStarboardPost(CachedMessage starredMessage, AUserInAServer starredUser, AUserInAServer starringUser, AServerAChannelMessage starboardPost);
StarboardPost createStarboardPost(CachedMessage starredMessage, AUserInAServer starredUser, AServerAChannelMessage starboardPost);
void setStarboardPostMessageId(StarboardPost post, Long messageId);
List<StarboardPost> retrieveTopPosts(Long serverId, Integer count);
List<StarboardPost> retrieveAllPosts(Long serverId);

13
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/listener/ReactionUpdatedListener.java
View File

@@ -2,15 +2,11 @@ package dev.sheldan.abstracto.core.listener;
import dev.sheldan.abstracto.core.config.FeatureConfig;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.FeatureConfigService;
import dev.sheldan.abstracto.core.service.FeatureFlagService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReaction;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.utils.EmoteUtils;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.events.message.guild.react.GuildMessageReactionAddEvent;
import net.dv8tion.jda.api.events.message.guild.react.GuildMessageReactionRemoveAllEvent;
@@ -56,6 +52,9 @@ public class ReactionUpdatedListener extends ListenerAdapter {
@Autowired
private BotService botService;
@Autowired
private EmoteService emoteService;
@Override
@Transactional
public void onGuildMessageReactionAdd(@Nonnull GuildMessageReactionAddEvent event) {
@@ -79,7 +78,7 @@ public class ReactionUpdatedListener extends ListenerAdapter {
private void addReactionIfNotThere(CachedMessage message, CachedReaction reaction, AUserInAServer userReacting) {
Optional<CachedReaction> existingReaction = message.getReactions().stream().filter(reaction1 ->
EmoteUtils.compareAEmote(reaction1.getEmote(), reaction.getEmote())
emoteService.compareAEmote(reaction1.getEmote(), reaction.getEmote())
).findAny();
if(!existingReaction.isPresent()) {
message.getReactions().add(reaction);
@@ -94,7 +93,7 @@ public class ReactionUpdatedListener extends ListenerAdapter {
private void removeReactionIfThere(CachedMessage message, CachedReaction reaction, AUserInAServer userReacting) {
Optional<CachedReaction> existingReaction = message.getReactions().stream().filter(reaction1 ->
EmoteUtils.compareAEmote(reaction1.getEmote(), reaction.getEmote())
emoteService.compareAEmote(reaction1.getEmote(), reaction.getEmote())
).findAny();
if(existingReaction.isPresent()) {
CachedReaction cachedReaction = existingReaction.get();

35
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/EmoteServiceBean.java
View File

@@ -2,6 +2,8 @@ package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.config.DynamicKeyLoader;
import dev.sheldan.abstracto.core.exception.EmoteNotDefinedException;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReaction;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.service.management.EmoteManagementService;
import lombok.extern.slf4j.Slf4j;
@@ -93,4 +95,37 @@ public class EmoteServiceBean implements EmoteService {
public String getDefaultEmote(String emoteKey) {
return keyLoader.getDefaultEmotes().get(emoteKey);
}
@Override
public boolean isReactionEmoteAEmote(MessageReaction.ReactionEmote reaction, AEmote storedEmote, Emote actualEmoteInGuild) {
if(reaction.isEmote() && storedEmote.getCustom()) {
if(actualEmoteInGuild != null) {
return actualEmoteInGuild.equals(reaction.getEmote());
} else {
return false;
}
} else if(reaction.isEmoji()){
return reaction.getEmoji().equals(storedEmote.getEmoteKey());
}
return false;
}
@Override
public Optional<CachedReaction> getReactionFromMessageByEmote(CachedMessage message, AEmote emote) {
return message.getReactions().stream().filter(reaction -> compareAEmote(reaction.getEmote(), emote)).findFirst();
}
@Override
public boolean compareAEmote(AEmote a, AEmote b) {
if(Boolean.TRUE.equals(a.getCustom()) && Boolean.TRUE.equals(b.getCustom())) {
return a.getEmoteId().equals(b.getEmoteId());
} else {
if(Boolean.FALSE.equals(a.getCustom()) && Boolean.FALSE.equals(b.getCustom())) {
return a.getEmoteKey().equals(b.getEmoteKey());
} else {
return false;
}
}
}
}

27
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/PostTargetServiceBean.java
View File

@@ -132,22 +132,23 @@ public class PostTargetServiceBean implements PostTargetService {
}
@Override
public void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target, List<CompletableFuture<Message>> future) {
public List<CompletableFuture<Message>> editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target) {
List<CompletableFuture<Message>> futures = new ArrayList<>();
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
CompletableFuture<Message> messageEditFuture = new CompletableFuture<>();
futures.add(messageEditFuture);
if(StringUtils.isBlank(messageToSend.getMessage().trim())) {
textChannelForPostTarget
.retrieveMessageById(messageId)
.queue(
existingMessage -> existingMessage
.editMessage(messageToSend.getEmbeds().get(0))
.submit().thenAccept(message -> future.get(0).complete(message)).exceptionally(throwable -> {
log.error("Failed to edit message {}.", messageId, throwable);
return null;
}),
.queue(messageEditFuture::complete, messageEditFuture::completeExceptionally),
throwable ->
sendEmbedInPostTarget(messageToSend, target).get(0)
.thenAccept(message -> future.get(0).complete(message)) .exceptionally(innerThrowable -> {
.thenAccept(messageEditFuture::complete).exceptionally(innerThrowable -> {
log.error("Failed to send message to create a message.", innerThrowable);
messageEditFuture.completeExceptionally(innerThrowable);
return null;
})
);
@@ -158,24 +159,24 @@ public class PostTargetServiceBean implements PostTargetService {
existingMessage -> existingMessage
.editMessage(messageToSend.getMessage())
.embed(messageToSend.getEmbeds().get(0))
.submit().thenAccept(message -> future.get(0).complete(message)).exceptionally(throwable -> {
log.error("Failed to edit message {}", messageId, throwable);
return null;
}),
.queue(messageEditFuture::complete, messageEditFuture::completeExceptionally),
throwable ->
sendEmbedInPostTarget(messageToSend, target).get(0)
.thenAccept(message -> future.get(0).complete(message)).exceptionally(innerThrowable -> {
.thenAccept(messageEditFuture::complete).exceptionally(innerThrowable -> {
log.error("Failed to send message to create a message.", innerThrowable);
messageEditFuture.completeExceptionally(innerThrowable);
return null;
})
);
}
return futures;
}
@Override
public void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTargetEnum postTargetName, Long serverId, List<CompletableFuture<Message>> future) {
public List<CompletableFuture<Message>> editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTargetEnum postTargetName, Long serverId) {
PostTarget postTarget = this.getPostTarget(postTargetName, serverId);
this.editOrCreatedInPostTarget(messageId, messageToSend, postTarget, future);
return this.editOrCreatedInPostTarget(messageId, messageToSend, postTarget);
}
@Override

1
abstracto-application/core/core-impl/src/main/resources/seedData/templates/exceptions/no_custom_emote_found_en_US.ftl
View File

@@ -1 +0,0 @@
<#include "no_custom_emote_found_text">

7
abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/EmoteService.java
View File

@@ -1,9 +1,13 @@
package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReaction;
import dev.sheldan.abstracto.core.models.database.AEmote;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.MessageReaction;
import java.util.Optional;
public interface EmoteService {
boolean isEmoteUsableByBot(Emote emote);
AEmote buildAEmoteFromReaction(MessageReaction.ReactionEmote reaction);
@@ -13,4 +17,7 @@ public interface EmoteService {
void throwIfEmoteDoesNotExist(String emoteKey, Long serverId);
AEmote getEmoteOrFakeEmote(String emoteKey, Long serverId);
String getDefaultEmote(String emoteKey);
boolean isReactionEmoteAEmote(MessageReaction.ReactionEmote reaction, AEmote storedEmote, Emote actualEmoteInGuild);
Optional<CachedReaction> getReactionFromMessageByEmote(CachedMessage message, AEmote emote);
boolean compareAEmote(AEmote a, AEmote b);
}

4
abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/PostTargetService.java
View File

@@ -21,8 +21,8 @@ public interface PostTargetService {
List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTarget target);
List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTarget target);
List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTargetEnum postTargetName, Long serverId);
void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target, List<CompletableFuture<Message>> future);
void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTargetEnum postTarget, Long serverId, List<CompletableFuture<Message>> future);
List<CompletableFuture<Message>> editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target);
List<CompletableFuture<Message>> editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTargetEnum postTarget, Long serverId);
void throwIfPostTargetIsNotDefined(PostTargetEnum name, Long serverId);
boolean validPostTarget(String name);
List<PostTarget> getPostTargets(AServer server);

46
abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/utils/EmoteUtils.java
View File

@@ -1,46 +0,0 @@
package dev.sheldan.abstracto.core.utils;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReaction;
import dev.sheldan.abstracto.core.models.database.AEmote;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.MessageReaction;
import java.util.Optional;
public class EmoteUtils {
private EmoteUtils() {
}
public static boolean isReactionEmoteAEmote(MessageReaction.ReactionEmote reaction, AEmote emote, Emote emoteInGuild) {
if(reaction.isEmote() && emote.getCustom()) {
if(emoteInGuild != null) {
return emoteInGuild.equals(reaction.getEmote());
} else {
return false;
}
} else if(reaction.isEmoji()){
return reaction.getEmoji().equals(emote.getEmoteKey());
}
return false;
}
public static Optional<CachedReaction> getReactionFromMessageByEmote(CachedMessage message, AEmote emote) {
return message.getReactions().stream().filter(reaction -> compareAEmote(reaction.getEmote(), emote)).findFirst();
}
public static boolean compareAEmote(AEmote a, AEmote b) {
if(Boolean.TRUE.equals(a.getCustom()) && Boolean.TRUE.equals(b.getCustom())) {
return a.getEmoteId().equals(b.getEmoteId());
} else {
if(Boolean.FALSE.equals(a.getCustom()) && Boolean.FALSE.equals(b.getCustom())) {
return a.getEmoteKey().equals(b.getEmoteKey());
} else {
return false;
}
}
}
}

1
abstracto-application/template-config/src/main/resources/templates/en_US/core/exception/no_custom_emote_found_text_en_US.ftl
View File

@@ -1 +0,0 @@
No custom emote found.

34
abstracto-application/test-commons/src/test/java/dev/sheldan/abstracto/test/MockUtils.java
View File

@@ -1,15 +1,6 @@
package dev.sheldan.abstracto.test;
import dev.sheldan.abstracto.core.models.database.*;
import net.dv8tion.jda.api.entities.MessageType;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.entities.*;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
public class MockUtils {
@@ -19,7 +10,7 @@ public class MockUtils {
public static AUserInAServer getUserObject(Long id, AServer server) {
AUser user = AUser.builder().id(id).build();
AUserInAServer createdUser = AUserInAServer.builder().userReference(user).serverReference(server).build();
AUserInAServer createdUser = AUserInAServer.builder().userReference(user).serverReference(server).userInServerId(id).build();
server.getUsers().add(createdUser);
return createdUser;
}
@@ -32,34 +23,11 @@ public class MockUtils {
return getServer(2L);
}
public static GuildImpl getGuild(AServer serverToUse, JDAImpl jda) {
return new GuildImpl(jda, serverToUse.getId());
}
public static MemberImpl getMockedMember(AServer serverToUse, AUserInAServer user, JDAImpl jda) {
UserImpl jdaUser = new UserImpl(user.getUserReference().getId(), jda);
GuildImpl jdaGuild = new GuildImpl(jda, serverToUse.getId());
return new MemberImpl(jdaGuild, jdaUser);
}
public static AChannel getTextChannel(AServer server, Long id) {
return AChannel.builder().id(id).server(server).deleted(false).type(AChannelType.TEXT).build();
}
public static TextChannelImpl getMockedTextChannel(Long id, GuildImpl guild) {
return new TextChannelImpl(id, guild);
}
public static ARole getRole(Long id, AServer server) {
return ARole.builder().server(server).id(id).build();
}
public static ReceivedMessage buildMockedMessage(long messageId, String text, MemberImpl member) {
Instant dateObj = Instant.ofEpochSecond(1590615937);
OffsetDateTime messageDate = OffsetDateTime.ofInstant(dateObj, ZoneId.systemDefault());
User user = member != null ? member.getUser() : null;
return new ReceivedMessage(messageId, null, MessageType.DEFAULT, false, false
, null, null, false, false, text, "nonce", user, member, null, messageDate,
new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), 0);
}
}

36
abstracto-application/test-commons/src/test/java/dev/sheldan/abstracto/test/command/CommandTestUtilities.java
View File

@@ -9,11 +9,12 @@ import dev.sheldan.abstracto.core.models.context.UserInitiatedServerContext;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.test.MockUtils;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.entities.GuildImpl;
import net.dv8tion.jda.internal.entities.MemberImpl;
import net.dv8tion.jda.internal.entities.TextChannelImpl;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.junit.Assert;
import org.mockito.Mockito;
import java.util.ArrayList;
import java.util.Arrays;
@@ -25,32 +26,32 @@ public class CommandTestUtilities {
}
public static void executeNoParametersTest(Command com, JDAImpl jda) {
CommandContext context = CommandTestUtilities.getNoParameters(jda);
public static void executeNoParametersTest(Command com) {
CommandContext context = CommandTestUtilities.getNoParameters();
com.execute(context);
}
public static void executeWrongParametersTest(Command com, JDAImpl jda) {
executeWrongParametersTest(com, jda, "");
public static void executeWrongParametersTest(Command com) {
executeWrongParametersTest(com, new ArrayList<>());
}
public static void executeWrongParametersTest(Command com, JDAImpl jda, Object value) {
CommandContext context = CommandTestUtilities.getWithParameters(jda, Arrays.asList(value));
public static void executeWrongParametersTest(Command com, Object value) {
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(value));
com.execute(context);
}
public static CommandContext getNoParameters(JDAImpl jda) {
public static CommandContext getNoParameters() {
AServer server = MockUtils.getServer();
AUserInAServer author = MockUtils.getUserObject(3L, server);
CommandContext context = CommandContext
.builder()
.build();
GuildImpl guild = MockUtils.getGuild(server, jda);
Guild guild = Mockito.mock(Guild.class);
context.setGuild(guild);
MemberImpl member = MockUtils.getMockedMember(server, author, jda);
Member member = Mockito.mock(Member.class);
context.setAuthor(member);
long channelId = 4L;
TextChannelImpl mockedTextChannel = MockUtils.getMockedTextChannel(channelId, guild);
TextChannel mockedTextChannel = Mockito.mock(TextChannel.class);
UserInitiatedServerContext userInitiatedContext = UserInitiatedServerContext
.builder()
.server(server)
@@ -62,15 +63,14 @@ public class CommandTestUtilities {
.messageChannel(mockedTextChannel)
.build();
context.setUserInitiatedContext(userInitiatedContext);
context.setJda(jda);
context.setChannel(mockedTextChannel);
context.setParameters(Parameters.builder().parameters(new ArrayList<>()).build());
context.setMessage(MockUtils.buildMockedMessage(3L, "text", member));
context.setMessage(Mockito.mock(Message.class));
return context;
}
public static CommandContext getWithParameters(JDAImpl jda, List<Object> parameters) {
CommandContext context = getNoParameters(jda);
public static CommandContext getWithParameters(List<Object> parameters) {
CommandContext context = getNoParameters();
context.getParameters().getParameters().addAll(parameters);
return context;
}