Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-03-30 23:15:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-182] added member parameter to starStats to show the starboard statistics for an individual member

Browse Source
This commit is contained in:
Sheldan
2021-02-14 23:43:44 +01:00
parent 876fbc01d9
commit 909dc87d94
24 changed files with 393 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -11,11 +11,13 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.MemberStarStatsModel;
import dev.sheldan.abstracto.utility.service.StarboardService;
import net.dv8tion.jda.api.entities.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@@ -23,6 +25,7 @@ import java.util.concurrent.CompletableFuture;
public class StarStats extends AbstractConditionableCommand {
public static final String STARSTATS_RESPONSE_TEMPLATE = "starStats_response";
public static final String STARSTATS_SINGLE_MEMBER_RESPONSE_TEMPLATE = "starStats_single_member_response";
@Autowired
private StarboardService starboardService;
@@ -32,15 +35,24 @@ public class StarStats extends AbstractConditionableCommand {
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
return starboardService.retrieveStarStats(commandContext.getGuild().getIdLong())
.thenCompose(starStatsModel ->
FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(STARSTATS_RESPONSE_TEMPLATE, starStatsModel, commandContext.getChannel()))
).thenApply(o -> CommandResult.fromIgnored());
List<Object> parameters = commandContext.getParameters().getParameters();
if(parameters.isEmpty()) {
return starboardService.retrieveStarStats(commandContext.getGuild().getIdLong())
.thenCompose(starStatsModel ->
FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(STARSTATS_RESPONSE_TEMPLATE, starStatsModel, commandContext.getChannel()))
).thenApply(o -> CommandResult.fromIgnored());
} else {
Member targetMember = (Member) parameters.get(0);
MemberStarStatsModel memberStarStatsModel = starboardService.retrieveStarStatsForMember(targetMember);
return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(STARSTATS_SINGLE_MEMBER_RESPONSE_TEMPLATE, memberStarStatsModel, commandContext.getChannel()))
.thenApply(unused -> CommandResult.fromIgnored());
}
}
@Override
public CommandConfiguration getConfiguration() {
List<Parameter> parameters = new ArrayList<>();
Parameter memberParameter = Parameter.builder().templated(true).name("member").type(Member.class).optional(true).build();
List<Parameter> parameters = Collections.singletonList(memberParameter);
HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
return CommandConfiguration.builder()
.name("starStats")

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

@@ -25,7 +25,7 @@ public class StarboardPostDeletedListener implements AsyncMessageDeletedListener
if(byStarboardPostId.isPresent()) {
StarboardPost post = byStarboardPostId.get();
log.info("Removing starboard post: message {}, channel {}, server {}, because the message was deleted",
post.getPostMessageId(), post.getSourceChanel().getId(), messageBefore.getServerId());
post.getPostMessageId(), post.getSourceChannel().getId(), messageBefore.getServerId());
starboardPostManagementService.setStarboardPostIgnored(messageBefore.getMessageId(), true);
}
}

2
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/repository/StarStatsUserResult.java → abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/repository/StarStatsGuildUserResult.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.utility.repository;
public interface StarStatsUserResult {
public interface StarStatsGuildUserResult {
// this is the User in Server Id
Long getUserId();
Integer getStarCount();

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

@@ -21,7 +21,7 @@ public interface StarboardPostReactionRepository extends JpaRepository<Starboard
"GROUP BY r.reactor_user_in_server_id \n" +
"ORDER BY starCount DESC \n" +
"LIMIT :count", nativeQuery = true)
List<StarStatsUserResult> findTopStarGiverInServer(Long serverId, Integer count);
List<StarStatsGuildUserResult> findTopStarGiverInServer(Long serverId, Integer count);
@Query(value = "SELECT COUNT(*) \n" +
"FROM starboard_post_reaction r \n" +
@@ -37,5 +37,5 @@ public interface StarboardPostReactionRepository extends JpaRepository<Starboard
"GROUP BY p.author_user_in_server_id \n" +
"ORDER BY starCount DESC \n" +
"LIMIT :count", nativeQuery = true)
List<StarStatsUserResult> retrieveTopStarReceiverInServer(Long serverId, Integer count);
List<StarStatsGuildUserResult> retrieveTopStarReceiverInServer(Long serverId, Integer count);
}

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

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.utility.repository;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
@@ -17,4 +18,31 @@ public interface StarboardPostRepository extends JpaRepository<StarboardPost, Lo
List<StarboardPost> findByServer_Id(Long serverId);
@Query(value = "SELECT p.id, COUNT(*) AS starCount \n" +
" FROM starboard_post p \n" +
" INNER JOIN starboard_post_reaction r ON p.id = r.post_id\n" +
" INNER JOIN user_in_server usi ON usi.user_in_server_id = p.author_user_in_server_id\n" +
" WHERE p.server_id = :serverId\n" +
" AND usi.user_id = :userId\n" +
" GROUP BY p.id \n" +
" ORDER BY starCount DESC \n" +
" LIMIT :count", nativeQuery = true)
List<Long> getTopStarboardPostsForUser(Long serverId, Long userId, Integer count);
@Query(value = "SELECT COUNT(*) AS starCount\n" +
"FROM starboard_post_reaction r \n" +
" INNER JOIN user_in_server usi ON usi.user_in_server_id = r.reactor_user_in_server_id \n" +
" WHERE usi.user_id = :userId \n" +
" AND r.server_id = :serverId", nativeQuery = true)
Long getGivenStarsOfUserInServer(Long serverId, Long userId);
@Query(value = "SELECT COUNT(*) AS starCount\n" +
" FROM starboard_post_reaction r \n" +
" INNER JOIN starboard_post p ON p.id = r.post_id \n" +
" INNER JOIN user_in_server usi ON usi.user_in_server_id = p.author_user_in_server_id \n" +
" WHERE p.author_user_in_server_id = usi.user_in_server_id \n" +
" AND usi.user_id = :userId \n" +
" AND r.server_id = :serverId", nativeQuery = true)
Long getReceivedStarsOfUserInServer(Long serverId, Long userId);
}

12
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/repository/converter/StarStatsUserConverter.java
View File

@@ -5,7 +5,7 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
import dev.sheldan.abstracto.utility.repository.StarStatsUserResult;
import dev.sheldan.abstracto.utility.repository.StarStatsGuildUserResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -22,7 +22,7 @@ public class StarStatsUserConverter {
@Autowired
private UserInServerManagementService userInServerManagementService;
public List<CompletableFuture<StarStatsUser>> convertToStarStatsUser(List<StarStatsUserResult> users, Long serverId) {
public List<CompletableFuture<StarStatsUser>> convertToStarStatsUser(List<StarStatsGuildUserResult> users, Long serverId) {
List<CompletableFuture<StarStatsUser>> result = new ArrayList<>();
users.forEach(starStatsUserResult ->
result.add(createStarStatsUser(serverId, starStatsUserResult))
@@ -30,15 +30,15 @@ public class StarStatsUserConverter {
return result;
}
private CompletableFuture<StarStatsUser> createStarStatsUser(Long serverId, StarStatsUserResult starStatsUserResult) {
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(starStatsUserResult.getUserId());
private CompletableFuture<StarStatsUser> createStarStatsUser(Long serverId, StarStatsGuildUserResult starStatsGuildUserResult) {
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(starStatsGuildUserResult.getUserId());
return memberService.getMemberInServerAsync(serverId, aUserInAServer.getUserReference().getId()).thenApply(member ->
StarStatsUser
.builder()
.starCount(starStatsUserResult.getStarCount())
.starCount(starStatsGuildUserResult.getStarCount())
.member(member)
// TODO properly load this instance instead of just building one
.user(AUser.builder().id(starStatsUserResult.getUserId()).build())
.user(AUser.builder().id(starStatsGuildUserResult.getUserId()).build())
.build()
);
}

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

@@ -23,7 +23,6 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -118,17 +117,16 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
}
@Transactional
public CompletionStage<Void> sendEmbeddingMessage(CachedMessage cachedMessage, TextChannel target, Long userEmbeddingUserInServerId, MessageEmbeddedModel messageEmbeddedModel) {
public CompletableFuture<Void> sendEmbeddingMessage(CachedMessage cachedMessage, TextChannel target, Long userEmbeddingUserInServerId, MessageEmbeddedModel messageEmbeddedModel) {
MessageToSend embed = templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, messageEmbeddedModel);
AUserInAServer cause = userInServerManagementService.loadOrCreateUser(userEmbeddingUserInServerId);
List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToSendToChannel(embed, target);
log.trace("Embedding message {} from channel {} from server {}, because of user {}", cachedMessage.getMessageId(),
cachedMessage.getChannelId(), cachedMessage.getServerId(), cause.getUserReference().getId());
Long userInServerId = cause.getUserInServerId();
return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenCompose(aVoid -> {
Message createdMessage = completableFutures.get(0).join();
return reactionService.addReactionToMessageAsync(REMOVAL_EMOTE, cachedMessage.getServerId(), createdMessage).thenAccept(aVoid1 ->
self.loadUserAndPersistMessage(cachedMessage, userInServerId, createdMessage)
self.loadUserAndPersistMessage(cachedMessage, userEmbeddingUserInServerId, createdMessage)
);
});
}

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

@@ -19,14 +19,12 @@ import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.config.features.StarboardFeature;
import dev.sheldan.abstracto.utility.config.posttargets.StarboardPostTarget;
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 dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarboardPostModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.*;
import dev.sheldan.abstracto.utility.service.management.StarboardPostManagementService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostReactorManagementService;
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.springframework.beans.factory.annotation.Autowired;
@@ -160,7 +158,7 @@ public class StarboardServiceBean implements StarboardService {
@Override
public CompletableFuture<Void> updateStarboardPost(StarboardPost post, CachedMessage message, List<AUserInAServer> userExceptAuthor) {
int starCount = userExceptAuthor.size();
log.info("Updating starboard post {} in server {} with reactors {}.", post.getId(), post.getSourceChanel().getServer().getId(), starCount);
log.info("Updating starboard post {} in server {} with reactors {}.", post.getId(), post.getSourceChannel().getServer().getId(), starCount);
return buildStarboardPostModel(message, starCount).thenCompose(starboardPostModel -> {
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel);
List<CompletableFuture<Message>> futures = postTargetService.editOrCreatedInPostTarget(post.getStarboardMessageId(), messageToSend, StarboardPostTarget.STARBOARD, message.getServerId());
@@ -175,12 +173,12 @@ public class StarboardServiceBean implements StarboardService {
@Override
public void deleteStarboardMessagePost(StarboardPost message) {
AChannel starboardChannel = message.getStarboardChannel();
log.info("Deleting starboard post {} in server {}", message.getId(), message.getSourceChanel().getServer().getId());
log.info("Deleting starboard post {} in server {}", message.getId(), message.getSourceChannel().getServer().getId());
messageService.deleteMessageInChannelInServer(starboardChannel.getServer().getId(), starboardChannel.getId(), message.getStarboardMessageId());
}
@Override
public CompletableFuture<StarStatsModel> retrieveStarStats(Long serverId) {
public CompletableFuture<GuildStarStatsModel> retrieveStarStats(Long serverId) {
int count = 3;
List<CompletableFuture<StarStatsUser>> topStarGiverFutures = starboardPostReactorManagementService.retrieveTopStarGiver(serverId, count);
List<CompletableFuture<StarStatsUser>> topStarReceiverFutures = starboardPostReactorManagementService.retrieveTopStarReceiver(serverId, count);
@@ -198,7 +196,7 @@ public class StarboardServiceBean implements StarboardService {
}
List<StarStatsUser> topStarGivers = topStarGiverFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
List<StarStatsUser> topStarReceiver = topStarReceiverFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
return StarStatsModel
return GuildStarStatsModel
.builder()
.badgeEmotes(emotes)
.starGiver(topStarGivers)
@@ -211,11 +209,32 @@ public class StarboardServiceBean implements StarboardService {
}
@Override
public MemberStarStatsModel retrieveStarStatsForMember(Member member) {
int count = 3;
Long receivedStars = starboardPostManagementService.retrieveReceivedStarsOfUserInServer(member.getGuild().getIdLong(), member.getIdLong());
Long givenStars = starboardPostManagementService.retrieveGivenStarsOfUserInServer(member.getGuild().getIdLong(), member.getIdLong());
List<StarboardPost> topPosts = starboardPostManagementService.retrieveTopPostsForUserInServer(member.getGuild().getIdLong(), member.getIdLong(), count);
List<StarStatsPost> starStatsPosts = topPosts.stream().map(this::fromStarboardPost).collect(Collectors.toList());
List<String> emotes = new ArrayList<>();
for (int i = 1; i < count + 1; i++) {
emotes.add(getStarboardRankingEmote(member.getGuild().getIdLong(), i));
}
return MemberStarStatsModel
.builder()
.member(member)
.topPosts(starStatsPosts)
.badgeEmotes(emotes)
.receivedStars(receivedStars)
.givenStars(givenStars)
.build();
}
public StarStatsPost fromStarboardPost(StarboardPost starboardPost) {
AChannel channel = starboardPost.getStarboardChannel();
return StarStatsPost
.builder()
.serverId(channel.getServer().getId())
.serverId(starboardPost.getServer().getId())
.channelId(channel.getId())
.messageId(starboardPost.getPostMessageId())
.starCount(starboardPost.getReactions().size())

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

@@ -34,7 +34,7 @@ public class StarboardPostManagementServiceBean implements StarboardPostManageme
.builder()
.author(starredUser)
.postMessageId(starredMessage.getMessageId())
.sourceChanel(build)
.sourceChannel(build)
.ignored(false)
.server(starboardPost.getServer())
.starboardMessageId(starboardPost.getMessageId())
@@ -63,6 +63,22 @@ public class StarboardPostManagementServiceBean implements StarboardPostManageme
return posts.subList(0, Math.min(count, posts.size()));
}
@Override
public List<StarboardPost> retrieveTopPostsForUserInServer(Long serverId, Long userId, Integer count) {
List<Long> topPostIds = repository.getTopStarboardPostsForUser(serverId, userId, count);
return repository.findAllById(topPostIds);
}
@Override
public Long retrieveGivenStarsOfUserInServer(Long serverId, Long userId) {
return repository.getGivenStarsOfUserInServer(serverId, userId);
}
@Override
public Long retrieveReceivedStarsOfUserInServer(Long serverId, Long userId) {
return repository.getReceivedStarsOfUserInServer(serverId, userId);
}
@Override
public List<StarboardPost> retrieveAllPosts(Long serverId) {
return repository.findByServer_Id(serverId);

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

@@ -4,7 +4,7 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
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.StarStatsGuildUserResult;
import dev.sheldan.abstracto.utility.repository.StarboardPostReactionRepository;
import dev.sheldan.abstracto.utility.repository.converter.StarStatsUserConverter;
import lombok.extern.slf4j.Slf4j;
@@ -55,13 +55,13 @@ public class StarboardPostReactorManagementServiceBean implements StarboardPostR
@Override
public List<CompletableFuture<StarStatsUser>> retrieveTopStarGiver(Long serverId, Integer count) {
List<StarStatsUserResult> starGivers = repository.findTopStarGiverInServer(serverId, count);
List<StarStatsGuildUserResult> starGivers = repository.findTopStarGiverInServer(serverId, count);
return converter.convertToStarStatsUser(starGivers, serverId);
}
@Override
public List<CompletableFuture<StarStatsUser>> retrieveTopStarReceiver(Long serverId, Integer count) {
List<StarStatsUserResult> starReceivers = repository.retrieveTopStarReceiverInServer(serverId, count);
List<StarStatsGuildUserResult> starReceivers = repository.retrieveTopStarReceiverInServer(serverId, count);
return converter.convertToStarStatsUser(starReceivers, serverId);
}

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

@@ -5,14 +5,18 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.GuildStarStatsModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.MemberStarStatsModel;
import dev.sheldan.abstracto.utility.service.StarboardService;
import net.dv8tion.jda.api.entities.Member;
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.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@@ -32,13 +36,25 @@ public class StarStatsTest {
@Test
public void executeCommand() {
CommandContext noParameters = CommandTestUtilities.getNoParameters();
StarStatsModel starStatsModel = StarStatsModel.builder().build();
when(starboardService.retrieveStarStats(noParameters.getGuild().getIdLong())).thenReturn(CompletableFuture.completedFuture(starStatsModel));
GuildStarStatsModel guildStarStatsModel = GuildStarStatsModel.builder().build();
when(starboardService.retrieveStarStats(noParameters.getGuild().getIdLong())).thenReturn(CompletableFuture.completedFuture(guildStarStatsModel));
CompletableFuture<CommandResult> result = testUnit.executeAsync(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(StarStats.STARSTATS_RESPONSE_TEMPLATE, starStatsModel, noParameters.getChannel());
verify(channelService, times(1)).sendEmbedTemplateInChannel(StarStats.STARSTATS_RESPONSE_TEMPLATE, guildStarStatsModel, noParameters.getChannel());
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
}
@Test
public void executeCommandForMember() {
Member member = Mockito.mock(Member.class);
CommandContext memberParameter = CommandTestUtilities.getWithParameters(Arrays.asList(member));
MemberStarStatsModel model = Mockito.mock(MemberStarStatsModel.class);
when(starboardService.retrieveStarStatsForMember(member)).thenReturn(model);
CompletableFuture<CommandResult> result = testUnit.executeAsync(memberParameter);
verify(channelService, times(1)).sendEmbedTemplateInChannel(StarStats.STARSTATS_SINGLE_MEMBER_RESPONSE_TEMPLATE, model, memberParameter.getChannel());
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
}
@Test
public void validateCommand() {
CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());

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

@@ -41,7 +41,7 @@ public class StarboardPostDeletedListenerTest {
Long serverId = 3L;
AChannel sourceChannel = Mockito.mock(AChannel.class);
StarboardPost post = Mockito.mock(StarboardPost.class);
when(post.getSourceChanel()) .thenReturn(sourceChannel);
when(post.getSourceChannel()) .thenReturn(sourceChannel);
when(post.getPostMessageId()).thenReturn(postMessageId);
when(starboardPostManagementService.findByStarboardPostId(messageId)).thenReturn(Optional.of(post));
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);

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

@@ -5,7 +5,7 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
import dev.sheldan.abstracto.utility.repository.StarStatsUserResult;
import dev.sheldan.abstracto.utility.repository.StarStatsGuildUserResult;
import net.dv8tion.jda.api.entities.Member;
import org.junit.Assert;
import org.junit.Test;
@@ -40,8 +40,8 @@ public class StarStatsUserConverterTest {
Integer firstStarCount = 5;
Long secondUserId = 9L;
Integer secondStarCount = 10;
List<StarStatsUserResult> results = new ArrayList<>();
StarStatsUserResult firstResult = Mockito.mock(StarStatsUserResult.class);
List<StarStatsGuildUserResult> results = new ArrayList<>();
StarStatsGuildUserResult firstResult = Mockito.mock(StarStatsGuildUserResult.class);
Member firstMember = Mockito.mock(Member.class);
AUserInAServer firstUser = Mockito.mock(AUserInAServer.class);
AUser firstAUser = Mockito.mock(AUser.class);
@@ -52,7 +52,7 @@ public class StarStatsUserConverterTest {
when(firstResult.getUserId()).thenReturn(firstUserId);
when(firstResult.getStarCount()).thenReturn(firstStarCount);
results.add(firstResult);
StarStatsUserResult secondResult = Mockito.mock(StarStatsUserResult.class);
StarStatsGuildUserResult secondResult = Mockito.mock(StarStatsGuildUserResult.class);
Member secondMember = Mockito.mock(Member.class);
AUserInAServer secondUser = Mockito.mock(AUserInAServer.class);
AUser secondAUser = Mockito.mock(AUser.class);
@@ -80,7 +80,7 @@ public class StarStatsUserConverterTest {
@Test
public void testConversionOfEmptyList() {
Long serverId = 5L;
List<StarStatsUserResult> results = new ArrayList<>();
List<StarStatsGuildUserResult> results = new ArrayList<>();
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
verify(memberService, times(0)).getMemberInServer(eq(serverId), anyLong());

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

@@ -2,15 +2,19 @@ package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.models.template.listener.MessageEmbeddedModel;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
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;
@@ -24,7 +28,9 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import static dev.sheldan.abstracto.utility.service.MessageEmbedServiceBean.MESSAGE_EMBED_TEMPLATE;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
@@ -61,7 +67,7 @@ public class MessageEmbedServiceBeanTest {
private MessageEmbedPostManagementService messageEmbedPostManagementService;
@Mock
private MessageService messageService;
private ReactionService reactionService;
@Mock
private TextChannel textChannel;
@@ -69,6 +75,12 @@ public class MessageEmbedServiceBeanTest {
@Mock
private Message embeddingMessage;
@Mock
private Guild guild;
@Mock
private CachedMessage cachedMessage;
@Captor
private ArgumentCaptor<CachedMessage> cachedMessageArgumentCaptor;
@@ -87,6 +99,9 @@ public class MessageEmbedServiceBeanTest {
@Mock
private Member embeddingMember;
@Mock
private Member embeddedMember;
@Test
public void testNoLinkInString(){
String message = "test";
@@ -138,6 +153,7 @@ public class MessageEmbedServiceBeanTest {
@Test
public void testEmbedNoLinks() {
testUnit.embedLinks(new ArrayList<>(), textChannel, 5L, embeddingMessage);
verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
}
@Test
@@ -183,25 +199,8 @@ public class MessageEmbedServiceBeanTest {
Assert.assertEquals(secondMessageId, secondEmbeddedMessage.getMessageId());
}
private MessageEmbedLink mockMessageEmbedLink(Long messageId) {
MessageEmbedLink secondMessageEmbedLink = Mockito.mock(MessageEmbedLink.class);
when(secondMessageEmbedLink.getServerId()).thenReturn(SERVER_ID);
when(secondMessageEmbedLink.getChannelId()).thenReturn(CHANNEL_ID);
when(secondMessageEmbedLink.getMessageId()).thenReturn(messageId);
return secondMessageEmbedLink;
}
private CachedMessage mockCachedMessage(Long secondMessageId) {
CachedMessage secondCacheMessage = Mockito.mock(CachedMessage.class);
when(secondCacheMessage.getServerId()).thenReturn(SERVER_ID);
when(secondCacheMessage.getChannelId()).thenReturn(CHANNEL_ID);
when(secondCacheMessage.getMessageId()).thenReturn(secondMessageId);
return secondCacheMessage;
}
@Test
public void testLoadingEmbeddingModel() {
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
when(cachedAuthor.getAuthorId()).thenReturn(USER_ID);
@@ -222,8 +221,51 @@ public class MessageEmbedServiceBeanTest {
Long userEmbeddingUserInServerId = 5L;
when(userInServerManagementService.loadUserOptional(userEmbeddingUserInServerId)).thenReturn(Optional.empty());
testUnit.embedLink(cachedMessage, textChannel, userEmbeddingUserInServerId, embeddingMessage);
verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
}
@Test
public void testSendEmbeddingMessage() {
MessageEmbeddedModel embeddedModel = Mockito.mock(MessageEmbeddedModel.class);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, embeddedModel)).thenReturn(messageToSend);
AUser user = Mockito.mock(AUser.class);
when(embeddingUser.getUserReference()).thenReturn(user);
when(userInServerManagementService.loadOrCreateUser(EMBEDDING_USER_IN_SERVER_ID)).thenReturn(embeddingUser);
List<CompletableFuture<Message>> messageFutures = CommandTestUtilities.messageFutureList();
when(channelService.sendMessageToSendToChannel(messageToSend, textChannel)).thenReturn(messageFutures);
Message createdMessage = messageFutures.get(0).join();
when(reactionService.addReactionToMessageAsync(MessageEmbedServiceBean.REMOVAL_EMOTE, cachedMessage.getServerId(),
createdMessage)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<Void> future = testUnit.sendEmbeddingMessage(cachedMessage, textChannel, EMBEDDING_USER_IN_SERVER_ID, embeddedModel);
Assert.assertFalse(future.isCompletedExceptionally());
verify(self, times(1)).loadUserAndPersistMessage(cachedMessage, EMBEDDING_USER_IN_SERVER_ID, createdMessage);
}
@Test
public void testLoadUserAndPersistMessage() {
when(userInServerManagementService.loadOrCreateUser(EMBEDDING_USER_IN_SERVER_ID)).thenReturn(embeddingUser);
testUnit.loadUserAndPersistMessage(cachedMessage, EMBEDDING_USER_IN_SERVER_ID, embeddingMessage);
verify(messageEmbedPostManagementService, times(1)).createMessageEmbed(cachedMessage, embeddingMessage, embeddingUser);
}
@Test
public void testLoadMessageEmbedModel() {
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getChannelId()).thenReturn(CHANNEL_ID);
when(channelService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.of(textChannel));
when(embeddingMessage.getGuild()).thenReturn(guild);
when(embeddingMessage.getChannel()).thenReturn(textChannel);
when(embeddingMessage.getMember()).thenReturn(embeddingMember);
MessageEmbeddedModel createdModel = testUnit.loadMessageEmbedModel(embeddingMessage, cachedMessage, embeddedMember);
Assert.assertEquals(textChannel, createdModel.getSourceChannel());
Assert.assertEquals(guild, createdModel.getGuild());
Assert.assertEquals(textChannel, createdModel.getMessageChannel());
Assert.assertEquals(embeddedMember, createdModel.getAuthor());
Assert.assertEquals(embeddingMember, createdModel.getMember());
Assert.assertEquals(embeddingMember, createdModel.getEmbeddingUser());
Assert.assertEquals(cachedMessage, createdModel.getEmbeddedMessage());
}
private void executeTestWithTwoLinks(String message) {
List<MessageEmbedLink> linksInMessage = testUnit.getLinksInMessage(message);
Assert.assertEquals(2, linksInMessage.size());
@@ -237,4 +279,20 @@ public class MessageEmbedServiceBeanTest {
Assert.assertEquals(3, secondLink.getChannelId().intValue());
Assert.assertEquals(4, secondLink.getMessageId().intValue());
}
private MessageEmbedLink mockMessageEmbedLink(Long messageId) {
MessageEmbedLink secondMessageEmbedLink = Mockito.mock(MessageEmbedLink.class);
when(secondMessageEmbedLink.getServerId()).thenReturn(SERVER_ID);
when(secondMessageEmbedLink.getChannelId()).thenReturn(CHANNEL_ID);
when(secondMessageEmbedLink.getMessageId()).thenReturn(messageId);
return secondMessageEmbedLink;
}
private CachedMessage mockCachedMessage(Long secondMessageId) {
CachedMessage secondCacheMessage = Mockito.mock(CachedMessage.class);
when(secondCacheMessage.getServerId()).thenReturn(SERVER_ID);
when(secondCacheMessage.getChannelId()).thenReturn(CHANNEL_ID);
when(secondCacheMessage.getMessageId()).thenReturn(secondMessageId);
return secondCacheMessage;
}
}

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

@@ -21,7 +21,7 @@ import dev.sheldan.abstracto.utility.models.database.embed.PostIdentifier;
import dev.sheldan.abstracto.utility.models.database.result.RepostLeaderboardResult;
import dev.sheldan.abstracto.utility.service.management.PostedImageManagement;
import dev.sheldan.abstracto.utility.service.management.RepostManagementService;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.*;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -32,10 +32,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import static dev.sheldan.abstracto.utility.service.RepostServiceBean.*;
@@ -105,7 +102,13 @@ public class RepostServiceBeanTest {
private Repost repost;
@Mock
private CachedMessage message;
private CachedMessage cachedMessage;
@Mock
private Message message;
@Mock
private MessageChannel messageChannel;
@Mock
private CachedAuthor author;
@@ -203,23 +206,23 @@ public class RepostServiceBeanTest {
@Test
public void testProcessMessageAttachmentRepostCheckNoAttachment() {
when(message.getAttachments()).thenReturn(new ArrayList<>());
testUnit.processMessageAttachmentRepostCheck(message);
verify(message, times(0)).getChannelId();
when(cachedMessage.getAttachments()).thenReturn(new ArrayList<>());
testUnit.processMessageAttachmentRepostCheck(cachedMessage);
verify(cachedMessage, times(0)).getChannelId();
}
@Test
public void testProcessMessageAttachmentRepostCheckOneAttachmentNotExistingPost() {
generalSetupForRepostTest();
when(message.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(author.getAuthorId()).thenReturn(USER_ID);
when(message.getAuthor()).thenReturn(author);
when(message.getMessageId()).thenReturn(MESSAGE_ID);
when(cachedMessage.getAuthor()).thenReturn(author);
when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
CachedAttachment attachment = Mockito.mock(CachedAttachment.class);
when(message.getAttachments()).thenReturn(Arrays.asList(attachment));
when(cachedMessage.getAttachments()).thenReturn(Arrays.asList(attachment));
when(attachment.getProxyUrl()).thenReturn(URL);
setupSingleRepost();
testUnit.processMessageAttachmentRepostCheck(message);
testUnit.processMessageAttachmentRepostCheck(cachedMessage);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(0));
verify(reactionService, times(0)).addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@@ -229,13 +232,13 @@ public class RepostServiceBeanTest {
generalSetupForRepostTest();
setupForRepostCreation();
CachedAttachment attachment = Mockito.mock(CachedAttachment.class);
when(message.getAttachments()).thenReturn(Arrays.asList(attachment));
when(cachedMessage.getAttachments()).thenReturn(Arrays.asList(attachment));
when(attachment.getProxyUrl()).thenReturn(URL);
setupSingleHash(postedImage);
Long originalPostMessageId = MESSAGE_ID + 1;
when(postedImage.getPostId()).thenReturn(new PostIdentifier(originalPostMessageId, POSITION));
when(reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.processMessageAttachmentRepostCheck(message);
testUnit.processMessageAttachmentRepostCheck(cachedMessage);
verify(reactionService, times(0)).addDefaultReactionToMessageAsync(anyString(), eq(SERVER_ID), eq(CHANNEL_ID), eq(MESSAGE_ID));
verify(self, times(1)).persistRepost(originalPostMessageId, POSITION, SERVER_ID, USER_ID);
}
@@ -244,11 +247,11 @@ public class RepostServiceBeanTest {
public void testProcessMessageAttachmentRepostCheckTwoAttachmentsOneIsRepost() {
generalSetupForRepostTest();
setupForRepostCreation();
when(message.getServerId()).thenReturn(SERVER_ID);
when(message.getAuthor().getAuthorId()).thenReturn(USER_ID);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getAuthor().getAuthorId()).thenReturn(USER_ID);
CachedAttachment attachment = Mockito.mock(CachedAttachment.class);
CachedAttachment attachment2 = Mockito.mock(CachedAttachment.class);
when(message.getAttachments()).thenReturn(Arrays.asList(attachment, attachment2));
when(cachedMessage.getAttachments()).thenReturn(Arrays.asList(attachment, attachment2));
when(attachment.getProxyUrl()).thenReturn(URL);
setupSingleRepost();
String secondAttachmentUrl = URL + "2";
@@ -260,17 +263,17 @@ public class RepostServiceBeanTest {
when(postedImage.getPostId()).thenReturn(new PostIdentifier(originalPostMessageId, POSITION));
when(reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(reactionService.addDefaultReactionToMessageAsync(anyString(), eq(SERVER_ID), eq(CHANNEL_ID), eq(MESSAGE_ID))).thenReturn(CompletableFuture.completedFuture(null));
testUnit.processMessageAttachmentRepostCheck(message);
testUnit.processMessageAttachmentRepostCheck(cachedMessage);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(0));
verify(self, times(1)).persistRepost(originalPostMessageId, POSITION, SERVER_ID, USER_ID);
}
private void setupForRepostCreation() {
when(message.getMessageId()).thenReturn(MESSAGE_ID);
when(message.getServerId()).thenReturn(SERVER_ID);
when(message.getAuthor()).thenReturn(author);
when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getAuthor()).thenReturn(author);
when(author.getAuthorId()).thenReturn(USER_ID);
when(message.getChannelId()).thenReturn(CHANNEL_ID);
when(cachedMessage.getChannelId()).thenReturn(CHANNEL_ID);
}
private void generalSetupForRepostTest() {
@@ -298,13 +301,13 @@ public class RepostServiceBeanTest {
when(thumbnail.getProxyUrl()).thenReturn(URL);
when(firstEmbed.getCachedThumbnail()).thenReturn(thumbnail);
List<CachedEmbed> messageEmbeds = Arrays.asList(firstEmbed);
when(message.getServerId()).thenReturn(SERVER_ID);
when(message.getAuthor()).thenReturn(author);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getAuthor()).thenReturn(author);
when(author.getAuthorId()).thenReturn(USER_ID);
when(message.getMessageId()).thenReturn(MESSAGE_ID);
when(message.getAttachments()).thenReturn(new ArrayList<>());
when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
when(cachedMessage.getAttachments()).thenReturn(new ArrayList<>());
setupSingleRepost();
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, message);
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, cachedMessage);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(EMBEDDED_LINK_POSITION_START_INDEX));
verify(reactionService, times(0)).addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@@ -317,13 +320,13 @@ public class RepostServiceBeanTest {
when(image.getProxyUrl()).thenReturn(URL);
when(firstEmbed.getCachedImageInfo()).thenReturn(image);
List<CachedEmbed> messageEmbeds = Arrays.asList(firstEmbed);
when(message.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(author.getAuthorId()).thenReturn(USER_ID);
when(message.getAuthor()).thenReturn(author);
when(message.getMessageId()).thenReturn(MESSAGE_ID);
when(message.getAttachments()).thenReturn(new ArrayList<>());
when(cachedMessage.getAuthor()).thenReturn(author);
when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
when(cachedMessage.getAttachments()).thenReturn(new ArrayList<>());
setupSingleRepost();
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, message);
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, cachedMessage);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(EMBEDDED_LINK_POSITION_START_INDEX));
verify(reactionService, times(0)).addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@@ -337,19 +340,19 @@ public class RepostServiceBeanTest {
when(thumbnail.getProxyUrl()).thenReturn(URL);
when(firstEmbed.getCachedThumbnail()).thenReturn(thumbnail);
List<CachedEmbed> messageEmbeds = Arrays.asList(firstEmbed);
when(message.getAttachments()).thenReturn(new ArrayList<>());
when(cachedMessage.getAttachments()).thenReturn(new ArrayList<>());
setupSingleHash(postedImage);
Long originalPostMessageId = MESSAGE_ID + 1;
when(postedImage.getPostId()).thenReturn(new PostIdentifier(originalPostMessageId, POSITION));
when(reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, message);
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, cachedMessage);
verify(self, times(1)).persistRepost(originalPostMessageId, POSITION, SERVER_ID, USER_ID);
}
@Test
public void testIsRepostEmptyEmbedMessage() {
CachedEmbed messageEmbed = Mockito.mock(CachedEmbed.class);
Optional<PostedImage> emptyOptional = testUnit.getRepostFor(message, messageEmbed, POSITION);
Optional<PostedImage> emptyOptional = testUnit.getRepostFor(cachedMessage, messageEmbed, POSITION);
Assert.assertFalse(emptyOptional.isPresent());
}
@@ -365,7 +368,7 @@ public class RepostServiceBeanTest {
private void executeGetRepostForWithMessageId(Long originalPostMessageId, boolean shouldBePresent) {
CachedEmbed messageEmbed = setupSimpleRepostCheck(originalPostMessageId);
Optional<PostedImage> optional = testUnit.getRepostFor(message, messageEmbed, POSITION);
Optional<PostedImage> optional = testUnit.getRepostFor(cachedMessage, messageEmbed, POSITION);
Assert.assertEquals(shouldBePresent, optional.isPresent());
if(shouldBePresent && optional.isPresent()) {
Assert.assertEquals(postedImage, optional.get());
@@ -387,13 +390,13 @@ public class RepostServiceBeanTest {
@Test
public void testIsRepostWithRepost() {
CachedEmbed messageEmbed = setupSimpleRepostCheck(MESSAGE_ID + 1);
Assert.assertTrue(testUnit.isRepost(message, messageEmbed, POSITION));
Assert.assertTrue(testUnit.isRepost(cachedMessage, messageEmbed, POSITION));
}
@Test
public void testIsRepostWithSameMessage() {
CachedEmbed messageEmbed = setupSimpleRepostCheck(MESSAGE_ID);
Assert.assertFalse(testUnit.isRepost(message, messageEmbed, POSITION));
Assert.assertFalse(testUnit.isRepost(cachedMessage, messageEmbed, POSITION));
}
@Test
@@ -404,10 +407,61 @@ public class RepostServiceBeanTest {
when(postedImage.getPostId()).thenReturn(new PostIdentifier(MESSAGE_ID + 1, POSITION));
CachedAttachment attachment = Mockito.mock(CachedAttachment.class);
when(attachment.getProxyUrl()).thenReturn(URL);
when(message.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(author.getAuthorId()).thenReturn(USER_ID);
when(cachedMessage.getAuthor()).thenReturn(author);
Assert.assertTrue(testUnit.isRepost(cachedMessage, attachment, POSITION));
}
@Test
public void testGetRepostForEmpty() {
Optional<PostedImage> repost = testUnit.getRepostFor(message, Mockito.mock(MessageEmbed.class), 1);
Assert.assertFalse(repost.isPresent());
}
@Test
public void testGetRepostForMessageThumbnail() {
MessageEmbed messageEmbed = Mockito.mock(MessageEmbed.class);
MessageEmbed.Thumbnail thumbnail = Mockito.mock(MessageEmbed.Thumbnail.class);
when(thumbnail.getProxyUrl()).thenReturn(URL);
when(messageEmbed.getThumbnail()).thenReturn(thumbnail);
generalSetupForRepostTest();
setupForRepostCreation();
setupSingleHash(postedImage);
when(postedImage.getPostId()).thenReturn(new PostIdentifier(2L, POSITION));
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
User author = Mockito.mock(User.class);
when(author.getIdLong()).thenReturn(USER_ID);
when(message.getAuthor()).thenReturn(author);
Assert.assertTrue(testUnit.isRepost(message, attachment, POSITION));
when(message.getChannel()).thenReturn(messageChannel);
when(messageChannel.getIdLong()).thenReturn(CHANNEL_ID);
Optional<PostedImage> repost = testUnit.getRepostFor(message, messageEmbed, 1);
Assert.assertTrue(repost.isPresent());
repost.ifPresent(postedImage1 -> Assert.assertEquals(postedImage, postedImage1));
}
@Test
public void testProcessMessageEmbedsRepostCheck() {
MessageEmbed messageEmbed = Mockito.mock(MessageEmbed.class);
MessageEmbed.ImageInfo imageInfo = Mockito.mock(MessageEmbed.ImageInfo.class);
when(imageInfo.getProxyUrl()).thenReturn(URL);
when(messageEmbed.getImage()).thenReturn(imageInfo);
generalSetupForRepostTest();
setupForRepostCreation();
setupSingleHash(postedImage);
when(postedImage.getPostId()).thenReturn(new PostIdentifier(2L, POSITION));
when(message.getGuild()).thenReturn(guild);
when(message.getIdLong()).thenReturn(MESSAGE_ID);
when(guild.getIdLong()).thenReturn(SERVER_ID);
User author = Mockito.mock(User.class);
when(author.getIdLong()).thenReturn(USER_ID);
when(message.getAuthor()).thenReturn(author);
when(message.getChannel()).thenReturn(messageChannel);
when(messageChannel.getIdLong()).thenReturn(CHANNEL_ID);
when(reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.processMessageEmbedsRepostCheck(Collections.singletonList(messageEmbed), message);
verify(self, times(1)).persistRepost(2L, POSITION, SERVER_ID, USER_ID);
}

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

@@ -17,12 +17,10 @@ import dev.sheldan.abstracto.utility.config.features.StarboardFeature;
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.models.template.commands.starboard.*;
import dev.sheldan.abstracto.utility.service.management.StarboardPostManagementService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostReactorManagementService;
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;
@@ -33,10 +31,7 @@ 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.*;
import java.util.concurrent.CompletableFuture;
import static dev.sheldan.abstracto.utility.config.features.StarboardFeature.STAR_EMOTE_PREFIX;
@@ -94,7 +89,7 @@ public class StarboardServiceBeanTest {
private StarboardServiceBean self;
@Mock
private GuildImpl guild;
private Guild guild;
@Mock
private Message sendPost;
@@ -121,6 +116,8 @@ public class StarboardServiceBeanTest {
private static final Long FIRST_USER_IN_SERVER_ID = 3L;
private static final Long SECOND_USER_IN_SERVER_ID = 9L;
private static final Long CHANNEL_ID = 10L;
private static final Long MESSAGE_ID = 11L;
private static final Long SECOND_MESSAGE_ID = 12L;
@Captor
private ArgumentCaptor<AUserInAServer> userInAServerArgumentCaptor;
@@ -219,7 +216,7 @@ public class StarboardServiceBeanTest {
Long starboardPostId = 47L;
StarboardPost post = Mockito.mock(StarboardPost.class);
when(post.getStarboardMessageId()).thenReturn(oldPostId);
when(post.getSourceChanel()).thenReturn(sourceChannel);
when(post.getSourceChannel()).thenReturn(sourceChannel);
when(post.getId()).thenReturn(starboardPostId);
MessageToSend postMessage = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(StarboardServiceBean.STARBOARD_POST_TEMPLATE), starboardPostModelArgumentCaptor.capture())).thenReturn(postMessage);
@@ -241,17 +238,16 @@ public class StarboardServiceBeanTest {
@Test
public void testDeleteStarboardMessagePost() {
Long messageId = 4L;
StarboardPost post = Mockito.mock(StarboardPost.class);
when(post.getStarboardMessageId()).thenReturn(messageId);
when(post.getStarboardMessageId()).thenReturn(MESSAGE_ID);
AChannel channel = Mockito.mock(AChannel.class);
when(channel.getServer()).thenReturn(server);
when(server.getId()).thenReturn(SERVER_ID);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(post.getSourceChanel()).thenReturn(channel);
when(post.getSourceChannel()).thenReturn(channel);
when(post.getStarboardChannel()).thenReturn(channel);
testUnit.deleteStarboardMessagePost(post);
verify(messageService, times(1)).deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, messageId);
verify(messageService, times(1)).deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@Test(expected = UserInServerNotFoundException.class)
@@ -267,18 +263,17 @@ public class StarboardServiceBeanTest {
public void testRetrieveStarStats() {
Integer limit = 3;
AChannel channel = Mockito.mock(AChannel.class);
when(channel.getServer()).thenReturn(server);
when(server.getId()).thenReturn(SERVER_ID);
Long firstPostMessageId = 50L;
Long secondPostMessageId = 51L;
StarboardPostReaction reaction = Mockito.mock(StarboardPostReaction.class);
StarboardPost post1 = Mockito.mock(StarboardPost.class);
when(post1.getReactions()).thenReturn(Arrays.asList(reaction));
when(post1.getPostMessageId()).thenReturn(firstPostMessageId);
when(post1.getPostMessageId()).thenReturn(MESSAGE_ID);
when(post1.getServer()).thenReturn(server);
when(post1.getStarboardChannel()).thenReturn(channel);
StarboardPost post2 = Mockito.mock(StarboardPost.class);
when(post2.getPostMessageId()).thenReturn(secondPostMessageId);
when(post2.getPostMessageId()).thenReturn(SECOND_MESSAGE_ID);
when(post2.getReactions()).thenReturn(new ArrayList<>());
when(post2.getServer()).thenReturn(server);
when(post2.getStarboardChannel()).thenReturn(channel);
List<StarboardPost> topPosts = Arrays.asList(post1, post2);
when(starboardPostManagementService.retrieveTopPosts(SERVER_ID, limit)).thenReturn(topPosts);
@@ -292,8 +287,8 @@ public class StarboardServiceBeanTest {
when(emoteService.getUsableEmoteOrDefault(SERVER_ID, "starboardBadge1")).thenReturn("1");
when(emoteService.getUsableEmoteOrDefault(SERVER_ID, "starboardBadge2")).thenReturn("2");
when(emoteService.getUsableEmoteOrDefault(SERVER_ID, "starboardBadge3")).thenReturn("3");
CompletableFuture<StarStatsModel> modelFuture = testUnit.retrieveStarStats(SERVER_ID);
StarStatsModel model = modelFuture.join();
CompletableFuture<GuildStarStatsModel> modelFuture = testUnit.retrieveStarStats(SERVER_ID);
GuildStarStatsModel model = modelFuture.join();
List<String> badgeEmotes = model.getBadgeEmotes();
Assert.assertEquals(limit.intValue(), badgeEmotes.size());
Assert.assertEquals("1", badgeEmotes.get(0));
@@ -304,14 +299,46 @@ public class StarboardServiceBeanTest {
StarStatsPost topPost = model.getTopPosts().get(0);
Assert.assertEquals(SERVER_ID, topPost.getServerId());
Assert.assertEquals(channel.getId(), topPost.getChannelId());
Assert.assertEquals(firstPostMessageId, topPost.getMessageId());
Assert.assertEquals(MESSAGE_ID, topPost.getMessageId());
Assert.assertEquals(1, topPost.getStarCount().intValue());
StarStatsPost secondTopPost = model.getTopPosts().get(1);
Assert.assertEquals(SERVER_ID, secondTopPost.getServerId());
Assert.assertEquals(channel.getId(), secondTopPost.getChannelId());
Assert.assertEquals(secondPostMessageId, secondTopPost.getMessageId());
Assert.assertEquals(SECOND_MESSAGE_ID, secondTopPost.getMessageId());
Assert.assertEquals(0, secondTopPost.getStarCount().intValue());
}
@Test
public void testRetrieveStarStatsForMember() {
when(starredMember.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(starredMember.getIdLong()).thenReturn(STARRED_USER_ID);
Long receivedStars = 3L;
Long givenStars = 3L;
when(starboardPostManagementService.retrieveReceivedStarsOfUserInServer(SERVER_ID, STARRED_USER_ID)).thenReturn(receivedStars);
when(starboardPostManagementService.retrieveGivenStarsOfUserInServer(SERVER_ID, STARRED_USER_ID)).thenReturn(givenStars);
StarboardPost post = Mockito.mock(StarboardPost.class);
AChannel starboardChannel = Mockito.mock(AChannel.class);
when(post.getStarboardChannel()).thenReturn(starboardChannel);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(post.getServer()).thenReturn(server);
StarboardPostReaction reaction = Mockito.mock(StarboardPostReaction.class);
when(post.getReactions()).thenReturn(Collections.singletonList(reaction));
when(starboardChannel.getId()).thenReturn(STARBOARD_CHANNEL_ID);
when(post.getPostMessageId()).thenReturn(MESSAGE_ID);
when(starboardPostManagementService.retrieveTopPostsForUserInServer(SERVER_ID, STARRED_USER_ID, 3)).thenReturn(Collections.singletonList(post));
MemberStarStatsModel returnedModel = testUnit.retrieveStarStatsForMember(starredMember);
Assert.assertEquals(receivedStars, returnedModel.getReceivedStars());
Assert.assertEquals(givenStars, returnedModel.getGivenStars());
Assert.assertEquals(starredMember, returnedModel.getMember());
Assert.assertEquals(3, returnedModel.getBadgeEmotes().size());
Assert.assertEquals(1, returnedModel.getTopPosts().size());
StarStatsPost starStatsPost = returnedModel.getTopPosts().get(0);
Assert.assertEquals(STARBOARD_CHANNEL_ID, starStatsPost.getChannelId());
Assert.assertEquals(SERVER_ID, starStatsPost.getServerId());
Assert.assertEquals(1, starStatsPost.getStarCount().longValue());
Assert.assertEquals(MESSAGE_ID, starStatsPost.getMessageId());
}
}

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

@@ -64,7 +64,7 @@ public class StarboardPostManagementServiceBeanTest {
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.assertEquals(sourceChannel.getId(), createdStarboardPost.getSourceChannel().getId());
Assert.assertFalse(createdStarboardPost.isIgnored());
}

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

@@ -6,7 +6,7 @@ import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.models.database.StarboardPostReaction;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsUser;
import dev.sheldan.abstracto.utility.repository.StarStatsUserResult;
import dev.sheldan.abstracto.utility.repository.StarStatsGuildUserResult;
import dev.sheldan.abstracto.utility.repository.StarboardPostReactionRepository;
import dev.sheldan.abstracto.utility.repository.converter.StarStatsUserConverter;
import org.junit.Assert;
@@ -131,9 +131,9 @@ public class StarboardPostReactorManagementServiceBeanTest {
}
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);
StarStatsGuildUserResult result1 = Mockito.mock(StarStatsGuildUserResult.class);
StarStatsGuildUserResult result2 = Mockito.mock(StarStatsGuildUserResult.class);
List<StarStatsGuildUserResult> results = Arrays.asList(result1, result2);
when(repository.findTopStarGiverInServer(serverId, amountToRetrieve)).thenReturn(results);
List<CompletableFuture<StarStatsUser>> statsUser = new ArrayList<>();
statsUser.add(CompletableFuture.completedFuture(user1));
@@ -144,9 +144,9 @@ public class StarboardPostReactorManagementServiceBeanTest {
}
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);
StarStatsGuildUserResult result1 = Mockito.mock(StarStatsGuildUserResult.class);
StarStatsGuildUserResult result2 = Mockito.mock(StarStatsGuildUserResult.class);
List<StarStatsGuildUserResult> results = Arrays.asList(result1, result2);
when(repository.retrieveTopStarReceiverInServer(serverId, amountToRetrieve)).thenReturn(results);
List<CompletableFuture<StarStatsUser>> statsUser = new ArrayList<>();
statsUser.add(CompletableFuture.completedFuture(user1));

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

@@ -46,7 +46,7 @@ public class StarboardPost implements Serializable {
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "source_channel_id", nullable = false)
private AChannel sourceChanel;
private AChannel sourceChannel;
@Transient
private Integer reactionCount;

2
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/models/template/commands/starboard/StarStatsModel.java → abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/models/template/commands/starboard/GuildStarStatsModel.java
View File

@@ -9,7 +9,7 @@ import java.util.List;
@Getter
@Setter
@Builder
public class StarStatsModel {
public class GuildStarStatsModel {
private List<StarStatsPost> topPosts;
private List<StarStatsUser> starReceiver;
private List<StarStatsUser> starGiver;

19
abstracto-application/abstracto-modules/utility/utility-int/src/main/java/dev/sheldan/abstracto/utility/models/template/commands/starboard/MemberStarStatsModel.java Normal file
View File

@@ -0,0 +1,19 @@
package dev.sheldan.abstracto.utility.models.template.commands.starboard;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import net.dv8tion.jda.api.entities.Member;
import java.util.List;
@Getter
@Setter
@Builder
public class MemberStarStatsModel {
private List<StarStatsPost> topPosts;
private Long receivedStars;
private Long givenStars;
private List<String> badgeEmotes;
private Member member;
}

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

@@ -3,8 +3,10 @@ package dev.sheldan.abstracto.utility.service;
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.GuildStarStatsModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.MemberStarStatsModel;
import dev.sheldan.abstracto.utility.models.template.commands.starboard.StarStatsPost;
import net.dv8tion.jda.api.entities.Member;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@@ -13,6 +15,7 @@ public interface StarboardService {
CompletableFuture<Void> createStarboardPost(CachedMessage message, List<AUserInAServer> userExceptAuthor, AUserInAServer userReacting, AUserInAServer starredUser);
CompletableFuture<Void> updateStarboardPost(StarboardPost post, CachedMessage message, List<AUserInAServer> userExceptAuthor);
void deleteStarboardMessagePost(StarboardPost message);
CompletableFuture<StarStatsModel> retrieveStarStats(Long serverId);
CompletableFuture<GuildStarStatsModel> retrieveStarStats(Long serverId);
MemberStarStatsModel retrieveStarStatsForMember(Member member);
StarStatsPost fromStarboardPost(StarboardPost starboardPost);
}

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

@@ -12,6 +12,9 @@ public interface StarboardPostManagementService {
StarboardPost createStarboardPost(CachedMessage starredMessage, AUserInAServer starredUser, AServerAChannelMessage starboardPost);
void setStarboardPostMessageId(StarboardPost post, Long messageId);
List<StarboardPost> retrieveTopPosts(Long serverId, Integer count);
List<StarboardPost> retrieveTopPostsForUserInServer(Long serverId, Long userId, Integer count);
Long retrieveGivenStarsOfUserInServer(Long serverId, Long userId);
Long retrieveReceivedStarsOfUserInServer(Long serverId, Long userId);
List<StarboardPost> retrieveAllPosts(Long serverId);
Integer getPostCount(Long serverId);
Optional<StarboardPost> findByMessageId(Long messageId);

4
abstracto-application/documentation/src/main/docs/asciidoc/modules/utility.adoc
View File

@@ -53,8 +53,8 @@ Feature key: `starboard`
==== Commands
Showing starboard statistics::
* Usage `starStats`
* Description: Shows the most starred posts, the member with the most received stars and the members rewarding the most stars.
* Usage `starStats [member]`
* Description: Shows the most starred posts, the member with the most received stars and the members rewarding the most stars. If `member` is provided, this command will show the top posts, received stars and given stars for this member. The user is still required to be part of the server.
=== Suggestions