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

[AB-139] changing the places at which there might be an uncached member object

Browse Source 
fixing integer validator
fixing syncing roles not working if the role did not change in the database
fixing warn id being flipped
fixing star stats model
This commit is contained in:
Sheldan
2020-10-11 22:04:18 +02:00
parent 1d3c414d6b
commit 36d11371cb
105 changed files with 1762 additions and 1086 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -11,7 +11,6 @@ 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.StarStatsModel;
import dev.sheldan.abstracto.utility.service.StarboardService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -33,9 +32,10 @@ public class StarStats extends AbstractConditionableCommand {
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
StarStatsModel result = starboardService.retrieveStarStats(commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(STARSTATS_RESPONSE_TEMPLATE, result, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromSuccess());
return starboardService.retrieveStarStats(commandContext.getGuild().getIdLong())
.thenCompose(starStatsModel ->
FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(STARSTATS_RESPONSE_TEMPLATE, starStatsModel, commandContext.getChannel()))
).thenApply(o -> CommandResult.fromSuccess());
}
@Override

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

@@ -47,7 +47,7 @@ public class MessageEmbedListener implements MessageReceivedListener {
continue;
}
messageRaw = messageRaw.replace(messageEmbedLink.getWholeUrl(), "");
Consumer<CachedMessage> cachedMessageConsumer = cachedMessage ->self.loadUserAndEmbed(message, userEmbeddingUserInServerId, cachedMessage);
Consumer<CachedMessage> cachedMessageConsumer = cachedMessage -> self.embedSingleLink(message, userEmbeddingUserInServerId, cachedMessage);
messageCache.getMessageFromCache(messageEmbedLink.getServerId(), messageEmbedLink.getChannelId(), messageEmbedLink.getMessageId())
.thenAccept(cachedMessageConsumer)
.exceptionally(throwable -> {
@@ -62,10 +62,14 @@ public class MessageEmbedListener implements MessageReceivedListener {
}
@Transactional
public void loadUserAndEmbed(Message message, Long cause, CachedMessage cachedMessage) {
public void embedSingleLink(Message message, Long cause, CachedMessage cachedMessage) {
log.info("Embedding link to message {} in channel {} in server {} to channel {} and server {}.",
cachedMessage.getMessageId(), cachedMessage.getChannelId(), cachedMessage.getServerId(), message.getChannel().getId(), message.getGuild().getId());
messageEmbedService.embedLink(cachedMessage, message.getTextChannel(), cause , message);
messageEmbedService.embedLink(cachedMessage, message.getTextChannel(), cause , message).exceptionally(throwable -> {
log.error("Failed to embed link towards message {} in channel {} in sever {} linked from message {} in channel {} in server {}.", cachedMessage.getMessageId(), cachedMessage.getChannelId(), cachedMessage.getServerId(),
message.getId(), message.getChannel().getId(), message.getGuild().getId(), throwable);
return null;
});
}
@Override

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

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

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

@@ -1,7 +1,9 @@
package dev.sheldan.abstracto.utility.repository.converter;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
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 org.springframework.beans.factory.annotation.Autowired;
@@ -9,6 +11,7 @@ import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Component
public class StarStatsUserConverter {
@@ -16,17 +19,26 @@ public class StarStatsUserConverter {
@Autowired
private BotService botService;
public List<StarStatsUser> convertToStarStatsUser(List<StarStatsUserResult> users, Long serverId) {
List<StarStatsUser> result = new ArrayList<>();
users.forEach(starStatsUserResult -> {
StarStatsUser newUser = StarStatsUser
.builder()
.starCount(starStatsUserResult.getStarCount())
.member(botService.getMemberInServer(serverId, starStatsUserResult.getUserId()))
.user(AUser.builder().id(starStatsUserResult.getUserId()).build())
.build();
result.add(newUser);
});
@Autowired
private UserInServerManagementService userInServerManagementService;
public List<CompletableFuture<StarStatsUser>> convertToStarStatsUser(List<StarStatsUserResult> users, Long serverId) {
List<CompletableFuture<StarStatsUser>> result = new ArrayList<>();
users.forEach(starStatsUserResult ->
result.add(createStarStatsUser(serverId, starStatsUserResult))
);
return result;
}
private CompletableFuture<StarStatsUser> createStarStatsUser(Long serverId, StarStatsUserResult starStatsUserResult) {
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(starStatsUserResult.getUserId());
return botService.getMemberInServerAsync(serverId, aUserInAServer.getUserReference().getId()).thenApply(member ->
StarStatsUser
.builder()
.starCount(starStatsUserResult.getStarCount())
.member(member)
.user(AUser.builder().id(starStatsUserResult.getUserId()).build())
.build()
);
}
}

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

@@ -28,7 +28,7 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CompletionStage;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -60,7 +60,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
private ChannelService channelService;
@Autowired
private MessageEmbedService self;
private MessageEmbedServiceBean self;
@Autowired
private MessageCache messageCache;
@@ -102,7 +102,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
.thenAccept(cachedMessage -> self.embedLink(cachedMessage, target, userEmbeddingUserInServerId, embeddingMessage)
).exceptionally(throwable -> {
log.error("Message retrieval from cache failed for message {}.", messageEmbedLink.getMessageId(), throwable);
log.error("Message embedding from cache failed for message {}.", messageEmbedLink.getMessageId(), throwable);
return null;
})
);
@@ -110,42 +110,50 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
@Override
@Transactional
public void embedLink(CachedMessage cachedMessage, TextChannel target, Long userEmbeddingUserInServerId, Message embeddingMessage) {
public CompletableFuture<Void> embedLink(CachedMessage cachedMessage, TextChannel target, Long userEmbeddingUserInServerId, Message embeddingMessage) {
Optional<AUserInAServer> causeOpt = userInServerManagementService.loadUserConditional(userEmbeddingUserInServerId);
if(causeOpt.isPresent()) {
AUserInAServer cause = causeOpt.get();
MessageEmbeddedModel messageEmbeddedModel = buildTemplateParameter(embeddingMessage, cachedMessage);
MessageToSend embed = templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, messageEmbeddedModel);
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();
CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
try {
Message createdMessage = completableFutures.get(0).get();
Optional<AUserInAServer> innerCauseOpt = userInServerManagementService.loadUserConditional(userInServerId);
innerCauseOpt.ifPresent(aUserInAServer -> {
messageEmbedPostManagementService.createMessageEmbed(cachedMessage, createdMessage, aUserInAServer);
messageService.addReactionToMessage(REMOVAL_EMOTE, cachedMessage.getServerId(), createdMessage);
});
} catch (InterruptedException | ExecutionException e) {
log.error("Failed to post message embed.", e);
Thread.currentThread().interrupt();
}
}).exceptionally(throwable -> {
log.error("Failed to send message for embedding the link for message {} in channel {} in server {}",
cachedMessage.getMessageId(), cachedMessage.getChannelId(), cachedMessage.getServerId(), throwable);
return null;
});
return buildTemplateParameter(embeddingMessage, cachedMessage).thenCompose(messageEmbeddedModel ->
self.sendEmbeddingMessage(cachedMessage, target, userEmbeddingUserInServerId, messageEmbeddedModel)
);
} else {
log.warn("User {} which was not found in database wanted to embed link in message {}.", userEmbeddingUserInServerId, embeddingMessage.getJumpUrl());
return CompletableFuture.completedFuture(null);
}
}
private MessageEmbeddedModel buildTemplateParameter(Message message, CachedMessage embeddedMessage) {
@Transactional
public CompletionStage<Void> sendEmbeddingMessage(CachedMessage cachedMessage, TextChannel target, Long userEmbeddingUserInServerId, MessageEmbeddedModel messageEmbeddedModel) {
MessageToSend embed = templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, messageEmbeddedModel);
AUserInAServer cause = userInServerManagementService.loadUser(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 messageService.addReactionToMessageWithFuture(REMOVAL_EMOTE, cachedMessage.getServerId(), createdMessage).thenAccept(aVoid1 ->
self.loadUserAndPersistMessage(cachedMessage, userInServerId, createdMessage)
);
});
}
@Transactional
public void loadUserAndPersistMessage(CachedMessage cachedMessage, Long userInServerId, Message createdMessage) {
AUserInAServer innerCause = userInServerManagementService.loadUser(userInServerId);
messageEmbedPostManagementService.createMessageEmbed(cachedMessage, createdMessage, innerCause);
}
private CompletableFuture<MessageEmbeddedModel> buildTemplateParameter(Message message, CachedMessage embeddedMessage) {
return botService.getMemberInServerAsync(embeddedMessage.getServerId(), embeddedMessage.getAuthorId()).thenApply(member ->
self.loadMessageEmbedModel(message, embeddedMessage, member)
);
}
@Transactional
public MessageEmbeddedModel loadMessageEmbedModel(Message message, CachedMessage embeddedMessage, Member member) {
AServer server = serverManagementService.loadOrCreate(message.getGuild().getIdLong());
AUserInAServer user = userInServerManagementService.loadUser(message.getMember());
Member author = botService.getMemberInServer(embeddedMessage.getServerId(), embeddedMessage.getAuthorId());
Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServerOptional(embeddedMessage.getServerId(), embeddedMessage.getChannelId());
TextChannel sourceChannel = textChannelFromServer.orElse(null);
AChannel channel = channelManagementService.loadChannel(message.getChannel().getIdLong());
@@ -155,7 +163,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
.server(server)
.member(message.getMember())
.aUserInAServer(user)
.author(author)
.author(member)
.sourceChannel(sourceChannel)
.embeddingUser(message.getMember())
.user(user.getUserReference())

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

@@ -5,8 +5,8 @@ import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.scheduling.service.SchedulerService;
@@ -36,6 +36,7 @@ import java.util.concurrent.*;
@Slf4j
public class RemindServiceBean implements ReminderService {
public static final String REMINDER_TEMPLATE_TEXT = "remind_reminder";
@Autowired
private ReminderManagementService reminderManagementService;
@@ -52,7 +53,7 @@ public class RemindServiceBean implements ReminderService {
private BotService botService;
@Autowired
private ReminderService self;
private RemindServiceBean self;
@Autowired
private ChannelService channelService;
@@ -61,6 +62,7 @@ public class RemindServiceBean implements ReminderService {
@Qualifier("reminderScheduler")
private ScheduledExecutorService instantReminderScheduler;
@Override
public Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Message message) {
AChannel channel = channelManagementService.loadChannel(message.getChannel().getIdLong());
@@ -99,7 +101,7 @@ public class RemindServiceBean implements ReminderService {
@Override
@Transactional
public void executeReminder(Long reminderId) {
Reminder reminderToRemindFor = reminderManagementService.loadReminder(reminderId).orElseThrow(() -> new ReminderNotFoundException(reminderId));
Reminder reminderToRemindFor = reminderManagementService.loadReminder(reminderId);
if(reminderToRemindFor.isReminded()) {
return;
}
@@ -107,22 +109,15 @@ public class RemindServiceBean implements ReminderService {
AChannel channel = reminderToRemindFor.getChannel();
log.info("Executing reminder {} in channel {} in server {} for user {}.",
reminderId, channel.getId(), server.getId(), reminderToRemindFor.getRemindedUser().getUserReference().getId());
Optional<Guild> guildToAnswerIn = botService.getGuildById(server.getId());
Optional<Guild> guildToAnswerIn = botService.getGuildByIdOptional(server.getId());
if(guildToAnswerIn.isPresent()) {
Optional<TextChannel> channelToAnswerIn = botService.getTextChannelFromServerOptional(server.getId(), channel.getId());
// only send the message if the channel still exists, if not, only set the reminder to reminded.
if(channelToAnswerIn.isPresent()) {
AUser userReference = reminderToRemindFor.getRemindedUser().getUserReference();
Member memberInServer = botService.getMemberInServer(server.getId(), userReference.getId());
log.trace("Reminding user {}", userReference.getId());
ExecutedReminderModel build = ExecutedReminderModel
.builder()
.reminder(reminderToRemindFor)
.member(memberInServer)
.duration(Duration.between(reminderToRemindFor.getReminderDate(), reminderToRemindFor.getTargetDate()))
.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate("remind_reminder", build);
channelService.sendMessageToSendToChannel(messageToSend, channelToAnswerIn.get());
botService.getMemberInServerAsync(server.getId(), reminderToRemindFor.getRemindedUser().getUserReference().getId()).thenAccept(member ->
self.sendReminderText(reminderId, channelToAnswerIn.get(), member)
);
} else {
log.warn("Channel {} in server {} to remind user did not exist anymore. Ignoring reminder {}", channel.getId(), server.getId(), reminderId);
}
@@ -132,6 +127,20 @@ public class RemindServiceBean implements ReminderService {
reminderManagementService.setReminded(reminderToRemindFor);
}
@Transactional
public CompletableFuture<Void> sendReminderText(Long reminderId, TextChannel channelToAnswerIn, Member member) {
Reminder reminder = reminderManagementService.loadReminder(reminderId);
log.trace("Sending remind message for reminder {} to user user {} in server {}.", reminderId, member.getIdLong(), member.getGuild().getIdLong());
ExecutedReminderModel build = ExecutedReminderModel
.builder()
.reminder(reminder)
.member(member)
.duration(Duration.between(reminder.getReminderDate(), reminder.getTargetDate()))
.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_TEMPLATE_TEXT, build);
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, channelToAnswerIn));
}
@Override
public void unRemind(Long reminderId, AUserInAServer aUserInAServer) {
log.info("Trying to end reminder {} for user {} in server {}.", reminderId, aUserInAServer.getUserReference().getId(),aUserInAServer.getServerReference().getId());

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

@@ -8,6 +8,7 @@ import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.*;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ConfigService;
@@ -32,6 +33,7 @@ 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.stream.Collectors;
@@ -80,22 +82,24 @@ public class StarboardServiceBean implements StarboardService {
private StarboardServiceBean self;
@Override
public void createStarboardPost(CachedMessage message, List<AUserInAServer> userExceptAuthor, AUserInAServer userReacting, AUserInAServer starredUser) {
StarboardPostModel starboardPostModel = buildStarboardPostModel(message, userExceptAuthor.size());
List<Long> userExceptAuthorIds = new ArrayList<>();
userExceptAuthor.forEach(aUserInAServer -> userExceptAuthorIds.add(aUserInAServer.getUserInServerId()));
public CompletableFuture<Void> createStarboardPost(CachedMessage message, List<AUserInAServer> userExceptAuthor, AUserInAServer userReacting, AUserInAServer starredUser) {
Long starredUserId = starredUser.getUserInServerId();
List<Long> userExceptAuthorIds = userExceptAuthor.stream().map(AUserInAServer::getUserInServerId).collect(Collectors.toList());
return buildStarboardPostModel(message, userExceptAuthor.size()).thenCompose(starboardPostModel ->
self.sendStarboardPostAndStore(message, starredUserId, userExceptAuthorIds, starboardPostModel)
);
}
@Transactional
public CompletionStage<Void> sendStarboardPostAndStore(CachedMessage message, Long starredUserId, List<Long> userExceptAuthorIds, StarboardPostModel starboardPostModel) {
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel);
PostTarget starboard = postTargetManagement.getPostTarget(StarboardPostTarget.STARBOARD.getKey(), message.getServerId());
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, StarboardPostTarget.STARBOARD, message.getServerId());
Long starboardChannelId = starboard.getChannelReference().getId();
Long starredUserId = starredUser.getUserInServerId();
CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid ->
self.persistPost(message, userExceptAuthorIds, completableFutures, starboardChannelId, starredUserId)
) .exceptionally(throwable -> {
log.error("Failed to create starboard post for message {} in channel {} in server {}", message.getMessageId(), message.getChannelId(), message.getServerId(), throwable);
return null;
});
return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid ->
self.persistPost(message, userExceptAuthorIds, completableFutures, starboardChannelId, starredUserId)
);
}
@Transactional
@@ -120,41 +124,41 @@ public class StarboardServiceBean implements StarboardService {
});
}
private StarboardPostModel buildStarboardPostModel(CachedMessage message, Integer starCount) {
Member member = botService.getMemberInServer(message.getServerId(), message.getAuthorId());
Optional<TextChannel> channel = botService.getTextChannelFromServerOptional(message.getServerId(), message.getChannelId());
Optional<Guild> guild = botService.getGuildById(message.getServerId());
AChannel aChannel = AChannel.builder().id(message.getChannelId()).build();
AUser user = AUser.builder().id(message.getAuthorId()).build();
AServer server = AServer.builder().id(message.getServerId()).build();
String starLevelEmote = getAppropriateEmote(message.getServerId(), starCount);
return StarboardPostModel
.builder()
.message(message)
.author(member)
.channel(channel.orElse(null))
.aChannel(aChannel)
.starCount(starCount)
.guild(guild.orElse(null))
.user(user)
.server(server)
.starLevelEmote(starLevelEmote)
.build();
private CompletableFuture<StarboardPostModel> buildStarboardPostModel(CachedMessage message, Integer starCount) {
return botService.getMemberInServerAsync(message.getServerId(), message.getAuthorId()).thenApply(member -> {
Optional<TextChannel> channel = botService.getTextChannelFromServerOptional(message.getServerId(), message.getChannelId());
Optional<Guild> guild = botService.getGuildByIdOptional(message.getServerId());
AChannel aChannel = AChannel.builder().id(message.getChannelId()).build();
AUser user = AUser.builder().id(message.getAuthorId()).build();
AServer server = AServer.builder().id(message.getServerId()).build();
String starLevelEmote = getAppropriateEmote(message.getServerId(), starCount);
return StarboardPostModel
.builder()
.message(message)
.author(member)
.channel(channel.orElse(null))
.aChannel(aChannel)
.starCount(starCount)
.guild(guild.orElse(null))
.user(user)
.server(server)
.starLevelEmote(starLevelEmote)
.build();
});
}
@Override
public void updateStarboardPost(StarboardPost post, CachedMessage message, List<AUserInAServer> userExceptAuthor) {
log.info("Updating starboard post {} in server {} with reactors {}.", post.getId(), post.getSourceChanel().getServer().getId(), userExceptAuthor.size());
StarboardPostModel starboardPostModel = buildStarboardPostModel(message, userExceptAuthor.size());
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel);
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 -> {
Optional<StarboardPost> innerPost = starboardPostManagementService.findByStarboardPostId(starboardPostId);
innerPost.ifPresent(starboardPost -> starboardPostManagementService.setStarboardPostMessageId(starboardPost, futures.get(0).join().getIdLong()));
}).exceptionally(throwable -> {
log.error("Failed to update starboard post {}.", post.getId(), throwable);
return null;
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);
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());
Long starboardPostId = post.getId();
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
Optional<StarboardPost> innerPost = starboardPostManagementService.findByStarboardPostId(starboardPostId);
innerPost.ifPresent(starboardPost -> starboardPostManagementService.setStarboardPostMessageId(starboardPost, futures.get(0).join().getIdLong()));
});
});
}
@@ -166,28 +170,35 @@ public class StarboardServiceBean implements StarboardService {
}
@Override
public StarStatsModel retrieveStarStats(Long serverId) {
public CompletableFuture<StarStatsModel> retrieveStarStats(Long serverId) {
int count = 3;
List<StarboardPost> starboardPosts = starboardPostManagementService.retrieveTopPosts(serverId, count);
List<StarStatsUser> topStarGivers = starboardPostReactorManagementService.retrieveTopStarGiver(serverId, count);
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);
List<String> emotes = new ArrayList<>();
for (int i = 1; i < count + 1; i++) {
emotes.add(getStarboardRankingEmote(serverId, i));
}
List<CompletableFuture<StarStatsUser>> topStarGiverFutures = starboardPostReactorManagementService.retrieveTopStarGiver(serverId, count);
List<CompletableFuture<StarStatsUser>> topStarReceiverFutures = starboardPostReactorManagementService.retrieveTopStarReceiver(serverId, count);
List<CompletableFuture> allFutures = new ArrayList<>();
allFutures.addAll(topStarGiverFutures);
allFutures.addAll(topStarReceiverFutures);
return FutureUtils.toSingleFuture(allFutures).thenApply(aVoid -> {
List<StarboardPost> starboardPosts = starboardPostManagementService.retrieveTopPosts(serverId, count);
List<StarStatsPost> starStatsPosts = starboardPosts.stream().map(this::fromStarboardPost).collect(Collectors.toList());
Integer postCount = starboardPostManagementService.getPostCount(serverId);
Integer reactionCount = starboardPostReactorManagementService.getStarCount(serverId);
List<String> emotes = new ArrayList<>();
for (int i = 1; i < count + 1; i++) {
emotes.add(getStarboardRankingEmote(serverId, i));
}
List<StarStatsUser> topStarGivers = topStarGiverFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
List<StarStatsUser> topStarReceiver = topStarReceiverFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
return StarStatsModel
.builder()
.badgeEmotes(emotes)
.starGiver(topStarGivers)
.starReceiver(topStarReceiver)
.topPosts(starStatsPosts)
.starredMessages(postCount)
.totalStars(reactionCount)
.build();
});
return StarStatsModel
.builder()
.badgeEmotes(emotes)
.starGiver(topStarGivers)
.starReceiver(topStarReceiver)
.topPosts(starStatsPosts)
.starredMessages(postCount)
.totalStars(reactionCount)
.build();
}
public StarStatsPost fromStarboardPost(StarboardPost starboardPost) {

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

@@ -1,10 +1,9 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
import dev.sheldan.abstracto.core.exception.GuildNotFoundException;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.CounterService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.MessageService;
@@ -73,7 +72,7 @@ public class SuggestionServiceBean implements SuggestionService {
long guildId = member.getGuild().getIdLong();
log.info("Creating suggestion with id {} in server {} from member {}.", newSuggestionId, member.getGuild().getId(), member.getId());
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, guildId);
return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenCompose(aVoid -> {
return FutureUtils.toSingleFutureGeneric(completableFutures).thenCompose(aVoid -> {
Message message = completableFutures.get(0).join();
log.trace("Posted message, adding reaction for suggestion {} to message {}.", newSuggestionId, message.getId());
CompletableFuture<Void> firstReaction = messageService.addReactionToMessageWithFuture(SUGGESTION_YES_EMOTE, guildId, message);
@@ -110,26 +109,22 @@ public class SuggestionServiceBean implements SuggestionService {
suggestionLog.setOriginalMessageId(originalMessageId);
suggestionLog.setOriginalMessageUrl(MessageUtils.buildMessageUrl(serverId, channelId, originalMessageId));
AUserInAServer suggester = suggestion.getSuggester();
Optional<Guild> guildByIdOptional = botService.getGuildById(serverId);
if(guildByIdOptional.isPresent()) {
Guild guildById = guildByIdOptional.get();
Member memberById = guildById.getMemberById(suggester.getUserReference().getId());
suggestionLog.setSuggester(memberById);
suggestionLog.setState(suggestion.getState());
suggestionLog.setSuggestionId(suggestion.getId());
TextChannel textChannelById = guildById.getTextChannelById(channelId);
if(textChannelById != null) {
return textChannelById.retrieveMessageById(originalMessageId).submit().thenCompose(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);
throw new ChannelNotFoundException(channelId);
TextChannel textChannelById = botService.getTextChannelFromServer(serverId, channelId);
CompletableFuture<Member> memberById = botService.getMemberInServerAsync(serverId, suggester.getUserReference().getId());
suggestionLog.setState(suggestion.getState());
suggestionLog.setSuggestionId(suggestion.getId());
CompletableFuture<Void> finalFuture = new CompletableFuture<>();
memberById.whenComplete((member, throwable) -> {
if(throwable == null) {
suggestionLog.setSuggester(member);
}
} else {
log.warn("Not possible to update suggestion {}, because guild {} was not found.", suggestion.getId(), serverId);
throw new GuildNotFoundException(serverId);
}
textChannelById.retrieveMessageById(originalMessageId).submit().thenCompose(message ->
self.updateSuggestionMessageText(text, suggestionLog, message)
).thenAccept(aVoid -> finalFuture.complete(null));
});
return finalFuture;
}
@Transactional(propagation = Propagation.REQUIRES_NEW)

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

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.utility.exception.ReminderNotFoundException;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.repository.ReminderRepository;
import lombok.extern.slf4j.Slf4j;
@@ -39,10 +40,15 @@ public class ReminderManagementServiceBean implements ReminderManagementService
}
@Override
public Optional<Reminder> loadReminder(Long reminderId) {
public Optional<Reminder> loadReminderOptional(Long reminderId) {
return reminderRepository.findById(reminderId);
}
@Override
public Reminder loadReminder(Long reminderId) {
return loadReminderOptional(reminderId).orElseThrow(() -> new ReminderNotFoundException(reminderId));
}
@Override
public void setReminded(Reminder reminder) {
reminder.setReminded(true);

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

@@ -12,6 +12,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Component
@Slf4j
@@ -52,13 +53,13 @@ public class StarboardPostReactorManagementServiceBean implements StarboardPostR
}
@Override
public List<StarStatsUser> retrieveTopStarGiver(Long serverId, Integer count) {
public List<CompletableFuture<StarStatsUser>> retrieveTopStarGiver(Long serverId, Integer count) {
List<StarStatsUserResult> starGivers = repository.findTopStarGiverInServer(serverId, count);
return converter.convertToStarStatsUser(starGivers, serverId);
}
@Override
public List<StarStatsUser> retrieveTopStarReceiver(Long serverId, Integer count) {
public List<CompletableFuture<StarStatsUser>> retrieveTopStarReceiver(Long serverId, Integer count) {
List<StarStatsUserResult> starReceivers = repository.retrieveTopStarReceiverInServer(serverId, count);
return converter.convertToStarStatsUser(starReceivers, serverId);
}

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

@@ -34,7 +34,7 @@ public class StarStatsTest {
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);
when(starboardService.retrieveStarStats(noParameters.getGuild().getIdLong())).thenReturn(CompletableFuture.completedFuture(starStatsModel));
CompletableFuture<CommandResult> result = testUnit.executeAsync(noParameters);
verify(channelService, times(1)).sendEmbedTemplateInChannel(StarStats.STARSTATS_RESPONSE_TEMPLATE, starStatsModel, noParameters.getChannel());
CommandTestUtilities.checkSuccessfulCompletionAsync(result);

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

@@ -83,7 +83,7 @@ public class MessageEmbedListenerTest {
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(self, times(1)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(message, times(1)).delete();
verify(deletionRestAction, times(1)).queue();
}
@@ -93,7 +93,7 @@ public class MessageEmbedListenerTest {
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(self, times(1)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
}
@@ -105,7 +105,7 @@ public class MessageEmbedListenerTest {
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(self, times(0)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
}
@@ -149,7 +149,7 @@ public class MessageEmbedListenerTest {
testUnit.execute(message);
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
verify(self, times(1)).loadUserAndEmbed(message, embeddingUser.getUserInServerId(), cachedMessage);
verify(self, times(1)).embedSingleLink(message, embeddingUser.getUserInServerId(), cachedMessage);
}
@Test
@@ -189,8 +189,8 @@ public class MessageEmbedListenerTest {
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);
verify(self, times(1)).embedSingleLink(message, userInAServer.getUserInServerId(), cachedMessage);
verify(self, times(1)).embedSingleLink(message, userInAServer.getUserInServerId(), secondCachedMessage);
}
@Test
@@ -198,8 +198,8 @@ public class MessageEmbedListenerTest {
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);
when(messageEmbedService.embedLink(cachedMessage, textChannel, userId, message)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.embedSingleLink(message, userId, cachedMessage);
}
private void executeLinkTestForOneLink(String text, String linkText, Long originServerId, Long embeddingServerId) {

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

@@ -1,6 +1,9 @@
package dev.sheldan.abstracto.utility.repository.converter;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
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 net.dv8tion.jda.api.entities.Member;
@@ -14,6 +17,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@@ -26,6 +30,8 @@ public class StarStatsUserConverterTest {
@Mock
private BotService botService;
@Mock
private UserInServerManagementService userInServerManagementService;
@Test
public void testConversionOfMultipleItems() {
@@ -37,24 +43,34 @@ public class StarStatsUserConverterTest {
List<StarStatsUserResult> results = new ArrayList<>();
StarStatsUserResult firstResult = Mockito.mock(StarStatsUserResult.class);
Member firstMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(serverId, firstUserId)).thenReturn(firstMember);
AUserInAServer firstUser = Mockito.mock(AUserInAServer.class);
AUser firstAUser = Mockito.mock(AUser.class);
when(firstAUser.getId()).thenReturn(firstUserId);
when(firstUser.getUserReference()).thenReturn(firstAUser);
when(userInServerManagementService.loadUser(firstUserId)).thenReturn(firstUser);
when(botService.getMemberInServerAsync(serverId, firstUserId)).thenReturn(CompletableFuture.completedFuture(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);
AUserInAServer secondUser = Mockito.mock(AUserInAServer.class);
AUser secondAUser = Mockito.mock(AUser.class);
when(secondAUser.getId()).thenReturn(secondUserId);
when(secondUser.getUserReference()).thenReturn(secondAUser);
when(userInServerManagementService.loadUser(secondUserId)).thenReturn(secondUser);
when(botService.getMemberInServerAsync(serverId, secondUserId)).thenReturn(CompletableFuture.completedFuture(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);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
StarStatsUser firstConverted = starStatsUsers.get(0).join();
Assert.assertEquals(firstStarCount, firstConverted.getStarCount());
Assert.assertEquals(firstMember, firstConverted.getMember());
Assert.assertEquals(firstUserId, firstConverted.getUser().getId());
StarStatsUser secondConverted = starStatsUsers.get(1);
StarStatsUser secondConverted = starStatsUsers.get(1).join();
Assert.assertEquals(secondStarCount, secondConverted.getStarCount());
Assert.assertEquals(secondMember, secondConverted.getMember());
Assert.assertEquals(secondUserId, secondConverted.getUser().getId());
@@ -66,7 +82,7 @@ public class StarStatsUserConverterTest {
Long serverId = 5L;
List<StarStatsUserResult> results = new ArrayList<>();
List<StarStatsUser> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
verify(botService, times(0)).getMemberInServer(eq(serverId), anyLong());
Assert.assertEquals(0, starStatsUsers.size());

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

@@ -1,8 +1,6 @@
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;
@@ -12,12 +10,9 @@ 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;
@@ -28,7 +23,6 @@ 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;
@@ -60,7 +54,7 @@ public class MessageEmbedServiceBeanTest {
private ChannelService channelService;
@Mock
private MessageEmbedService self;
private MessageEmbedServiceBean self;
@Mock
private MessageCache messageCache;
@@ -84,6 +78,16 @@ public class MessageEmbedServiceBeanTest {
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";
private static final Long EMBEDDING_USER_IN_SERVER_ID = 8L;
private static final Long SERVER_ID = 8L;
private static final Long USER_ID = 9L;
@Mock
private AUserInAServer embeddingUser;
@Mock
private Member embeddingMember;
@Test
public void testNoLinkInString(){
String message = "test";
@@ -182,38 +186,16 @@ public class MessageEmbedServiceBeanTest {
}
@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.loadUserConditional(userEmbeddingUserInServerId)).thenReturn(Optional.of(embeddingUser));
when(channelManagementService.loadChannel(channelId)).thenReturn(aChannel);
when(serverManagementService.loadOrCreate(serverId)).thenReturn(server);
when(botService.getMemberInServer(cachedMessage.getServerId(), cachedMessage.getAuthorId())).thenReturn(author);
when(botService.getTextChannelFromServerOptional(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);
public void testLoadingEmbeddingModel() {
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
when(cachedMessage.getAuthorId()).thenReturn(USER_ID);
when(userInServerManagementService.loadUserConditional(EMBEDDING_USER_IN_SERVER_ID)).thenReturn(Optional.of(embeddingUser));
when(botService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(embeddingMember));
MessageEmbeddedModel model = Mockito.mock(MessageEmbeddedModel.class);
when(self.loadMessageEmbedModel(embeddingMessage, cachedMessage, embeddingMember)).thenReturn(model);
when(self.sendEmbeddingMessage(cachedMessage, textChannel, EMBEDDING_USER_IN_SERVER_ID, model)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.embedLink(cachedMessage, textChannel, EMBEDDING_USER_IN_SERVER_ID, embeddingMessage).join();
}
@Test

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

@@ -14,7 +14,6 @@ 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;
@@ -32,10 +31,13 @@ import org.quartz.JobDataMap;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.Date;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import static dev.sheldan.abstracto.utility.service.RemindServiceBean.REMINDER_TEMPLATE_TEXT;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
@@ -74,6 +76,8 @@ public class RemindServiceBeanTest {
@Mock
private ScheduledExecutorService instantReminderScheduler;
private static final Long REMINDER_ID = 5L;
@Before
public void setup() {
when(message.getIdLong()).thenReturn(5L);
@@ -89,8 +93,7 @@ public class RemindServiceBeanTest {
String remindText = "text";
Duration duration = Duration.ofSeconds(62);
when(channelManagementService.loadChannel(channel.getIdLong())).thenReturn(aChannel);
Long reminderId = 5L;
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(reminderId).build();
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(REMINDER_ID).build();
Long messageId = 5L;
when(reminderManagementService.createReminder(any(AServerAChannelAUser.class), eq(remindText), any(Instant.class), eq(messageId))).thenReturn(createdReminder);
String triggerKey = "trigger";
@@ -111,8 +114,7 @@ public class RemindServiceBeanTest {
String remindText = "text";
Duration duration = Duration.ofSeconds(50);
when(channelManagementService.loadChannel(channel.getIdLong())).thenReturn(aChannel);
Long reminderId = 5L;
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(reminderId).build();
Reminder createdReminder = Reminder.builder().targetDate(Instant.now().plus(duration)).text(remindText).id(REMINDER_ID).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);
@@ -126,36 +128,31 @@ public class RemindServiceBeanTest {
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));
Reminder remindedReminder = Reminder.builder().reminded(false).remindedUser(remindedUser).reminderDate(Instant.now()).targetDate(Instant.now()).server(server).channel(aChannel).id(REMINDER_ID).build();
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
Guild guildMock = Mockito.mock(Guild.class);
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getTextChannelFromServerOptional(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);
when(botService.getMemberInServerAsync(server.getId(), remindedUser.getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(mockedMember));
testUnit.executeReminder(REMINDER_ID);
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;
AUserInAServer remindedUser = Mockito.mock(AUserInAServer.class);
AUser user = Mockito.mock(AUser.class);
when(user.getId()).thenReturn(6L);
when(remindedUser.getUserReference()).thenReturn(user);
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).remindedUser(remindedUser).channel(aChannel).id(reminderId).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.of(remindedReminder));
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).remindedUser(remindedUser).channel(aChannel).id(REMINDER_ID).build();
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
Guild guildMock = Mockito.mock(Guild.class);
when(botService.getGuildById(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@@ -170,8 +167,8 @@ public class RemindServiceBeanTest {
when(user.getId()).thenReturn(6L);
when(remindedUser.getUserReference()).thenReturn(user);
Reminder remindedReminder = Reminder.builder().reminded(false).server(server).channel(aChannel).remindedUser(remindedUser).id(reminderId).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.of(remindedReminder));
when(botService.getGuildById(server.getId())).thenReturn(Optional.empty());
when(reminderManagementService.loadReminder(reminderId)).thenReturn(remindedReminder);
when(botService.getGuildByIdOptional(server.getId())).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@@ -180,17 +177,9 @@ public class RemindServiceBeanTest {
public void testExecuteRemindedReminder() {
Long reminderId = 5L;
Reminder remindedReminder = Reminder.builder().reminded(true).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(Optional.of(remindedReminder));
when(reminderManagementService.loadReminder(reminderId)).thenReturn(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());
verify(botService, times(0)).getGuildByIdOptional(anyLong());
}
@Test
@@ -225,4 +214,21 @@ public class RemindServiceBeanTest {
testUnit.unRemind(reminderId, remindedUser);
}
@Test
public void testSendReminderText() {
Member remindedMember = Mockito.mock(Member.class);
Guild guild = Mockito.mock(Guild.class);
when(remindedMember.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(8L);
when(remindedMember.getIdLong()).thenReturn(9L);
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getTargetDate()).thenReturn(Instant.now());
when(remindedReminder.getReminderDate()).thenReturn(Instant.now());
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(REMINDER_TEMPLATE_TEXT), any())).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, channel)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
testUnit.sendReminderText(REMINDER_ID, channel, remindedMember).join();
}
}

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

@@ -40,6 +40,7 @@ import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import static dev.sheldan.abstracto.utility.service.StarboardServiceBean.STARBOARD_POST_TEMPLATE;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
@@ -93,6 +94,19 @@ public class StarboardServiceBeanTest {
@Mock
private TextChannel mockedTextChannel;
@Mock
private Member starredMember;
@Mock
private AChannel starboardChannel;
@Mock
private MessageToSend messageToSend;
private static final Long STARRED_USER_ID = 5L;
private static final Long SERVER_ID = 6L;
private static final Long STARBOARD_CHANNEL_ID = 8L;
@Captor
private ArgumentCaptor<AUserInAServer> userInAServerArgumentCaptor;
@@ -108,34 +122,40 @@ public class StarboardServiceBeanTest {
AUserInAServer userReacting = MockUtils.getUserObject(4L, server);
AUserInAServer starredUser = MockUtils.getUserObject(5L, server);
Long channelId = 10L;
Long starredUserId = starredUser.getUserReference().getId();
CachedMessage message = CachedMessage
.builder()
.authorId(starredUser.getUserReference().getId())
.authorId(starredUserId)
.serverId(server.getId())
.channelId(channelId)
.build();
Member authorMember = Mockito.mock(Member.class);
when(botService.getMemberInServer(message.getServerId(), message.getAuthorId())).thenReturn(authorMember);
when(botService.getMemberInServerAsync(message.getServerId(), message.getAuthorId())).thenReturn(CompletableFuture.completedFuture(authorMember));
when(botService.getTextChannelFromServerOptional(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(botService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guild));
ADefaultConfig config = ADefaultConfig.builder().longValue(3L).build();
when(defaultConfigManagementService.getDefaultConfig(StarboardServiceBean.STAR_LEVELS_CONFIG_KEY)).thenReturn(config);
when(configService.getLongValue("starLvl3", server.getId())).thenReturn(3L);
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()));
List<StarboardPostModel> starboardPostModels = starboardPostModelArgumentCaptor.getAllValues();
Assert.assertEquals(1, starboardPostModels.size());
StarboardPostModel usedModel = starboardPostModels.get(0);
Assert.assertEquals("b", usedModel.getStarLevelEmote());
when(self.sendStarboardPostAndStore(eq(message), eq(starredUserId), anyList(), any())).thenReturn(CompletableFuture.completedFuture(null));
testUnit.createStarboardPost(message, userExceptAuthor, userReacting, starredUser).join();
}
@Test
public void testSendStarboard() {
CachedMessage message = Mockito.mock(CachedMessage.class);
when(message.getServerId()).thenReturn(SERVER_ID);
StarboardPostModel model = Mockito.mock(StarboardPostModel.class);
when(templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, model)).thenReturn(messageToSend);
PostTarget postTarget = Mockito.mock(PostTarget.class);
when(postTarget.getChannelReference()).thenReturn(starboardChannel);
when(starboardChannel.getId()).thenReturn(STARBOARD_CHANNEL_ID);
when(postTargetManagement.getPostTarget(StarboardPostTarget.STARBOARD.getKey(), SERVER_ID)).thenReturn(postTarget);
when(postTargetService.sendEmbedInPostTarget(messageToSend, StarboardPostTarget.STARBOARD, SERVER_ID)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
ArrayList<Long> userExceptAuthorIds = new ArrayList<>();
testUnit.sendStarboardPostAndStore(message, STARRED_USER_ID, userExceptAuthorIds, model);
verify(self, times(1)).persistPost(eq(message), eq(userExceptAuthorIds), any(), eq(STARBOARD_CHANNEL_ID), eq(STARRED_USER_ID));
}
@Test
@@ -189,12 +209,13 @@ public class StarboardServiceBeanTest {
Long starboardPostId = 47L;
StarboardPost post = StarboardPost.builder().postMessageId(postMessageId).starboardMessageId(oldPostId).sourceChanel(sourceChannel).id(starboardPostId).build();
MessageToSend postMessage = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq(StarboardServiceBean.STARBOARD_POST_TEMPLATE), starboardPostModelArgumentCaptor.capture())).thenReturn(postMessage);
when(templateService.renderEmbedTemplate(eq(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);
ADefaultConfig config = ADefaultConfig.builder().longValue(4L).build();
when(defaultConfigManagementService.getDefaultConfig(StarboardServiceBean.STAR_LEVELS_CONFIG_KEY)).thenReturn(config);
when(starboardPostManagementService.findByStarboardPostId(starboardPostId)).thenReturn(Optional.of(post));
when(botService.getMemberInServerAsync(server.getId(), starredUser.getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(starredMember));
List<AUserInAServer > userExceptAuthor = new ArrayList<>();
testUnit.updateStarboardPost(post, message, userExceptAuthor);
verify(postTargetService, times(1)).editOrCreatedInPostTarget(oldPostId, postMessage, StarboardPostTarget.STARBOARD, server.getId());
@@ -237,9 +258,9 @@ public class StarboardServiceBeanTest {
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);
CompletableFuture<StarStatsUser> statsUser = CompletableFuture.completedFuture(Mockito.mock(StarStatsUser.class));
CompletableFuture<StarStatsUser> statsUser2 = CompletableFuture.completedFuture(Mockito.mock(StarStatsUser.class));
List<CompletableFuture<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);
@@ -247,7 +268,8 @@ public class StarboardServiceBeanTest {
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());
CompletableFuture<StarStatsModel> modelFuture = testUnit.retrieveStarStats(server.getId());
StarStatsModel model = modelFuture.join();
List<String> badgeEmotes = model.getBadgeEmotes();
Assert.assertEquals(limit.intValue(), badgeEmotes.size());
Assert.assertEquals("1", badgeEmotes.get(0));

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

@@ -1,9 +1,9 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
import dev.sheldan.abstracto.core.exception.GuildNotFoundException;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.CounterService;
@@ -11,7 +11,6 @@ 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;
@@ -74,49 +73,64 @@ public class SuggestionServiceBeanTest {
@Mock
private CounterService counterService;
@Mock
private AServer server;
@Mock
private AChannel channel;
@Mock
private AUserInAServer suggester;
@Mock
private AUser suggesterUser;
@Mock
private Member suggesterMember;
private static final Long SUGGESTER_ID = 8L;
private static final Long SERVER_ID = 3L;
private static final Long CHANNEL_ID = 7L;
private static final Long SUGGESTION_ID = 5L;
@Test
public void testCreateSuggestionMessage() {
String suggestionText = "text";
AServer server = MockUtils.getServer();
SuggestionLog log = Mockito.mock(SuggestionLog.class);
when(log.getServer()).thenReturn(server);
Long suggestionId = 5L;
when(suggestionCreator.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(server.getId());
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(guild.getIdLong()).thenReturn(SERVER_ID);
MessageToSend messageToSend = MessageToSend.builder().build();
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class))).thenReturn(messageToSend);
Message suggestionMessage = Mockito.mock(Message.class);
when(counterService.getNextCounterValue(server, SUGGESTION_COUNTER_KEY)).thenReturn(suggestionId);
when(counterService.getNextCounterValue(server, SUGGESTION_COUNTER_KEY)).thenReturn(SUGGESTION_ID);
List<CompletableFuture<Message>> postingFutures = Arrays.asList(CompletableFuture.completedFuture(suggestionMessage));
when(postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, server.getId())).thenReturn(postingFutures);
when(postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, SERVER_ID)).thenReturn(postingFutures);
testUnit.createSuggestionMessage(suggestionCreator, suggestionText, log);
verify( messageService, times(1)).addReactionToMessageWithFuture(SuggestionServiceBean.SUGGESTION_YES_EMOTE, server.getId(), suggestionMessage);
verify( messageService, times(1)).addReactionToMessageWithFuture(SuggestionServiceBean.SUGGESTION_NO_EMOTE, server.getId(), suggestionMessage);
verify( messageService, times(1)).addReactionToMessageWithFuture(SuggestionServiceBean.SUGGESTION_YES_EMOTE, SERVER_ID, suggestionMessage);
verify( messageService, times(1)).addReactionToMessageWithFuture(SuggestionServiceBean.SUGGESTION_NO_EMOTE, SERVER_ID, suggestionMessage);
}
@Test
public void testCreateSuggestion() {
Member member = Mockito.mock(Member.class);
when(member.getGuild()).thenReturn(guild);
when(suggesterMember.getGuild()).thenReturn(guild);
when(guild.getId()).thenReturn("5");
String text = "text";
Message message = Mockito.mock(Message.class);
Long suggestionId = 3L;
testUnit.persistSuggestionInDatabase(member, text, message, suggestionId);
verify(suggestionManagementService, times(1)).createSuggestion(member, text, message, suggestionId);
testUnit.persistSuggestionInDatabase(suggesterMember, text, message, SUGGESTION_ID);
verify(suggestionManagementService, times(1)).createSuggestion(suggesterMember, text, message, SUGGESTION_ID);
}
@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());
when(suggestionManagementService.getSuggestion(SUGGESTION_ID)).thenReturn(Optional.empty());
testUnit.acceptSuggestion(SUGGESTION_ID, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test
@@ -126,38 +140,24 @@ public class SuggestionServiceBeanTest {
@Test(expected = ChannelNotFoundException.class)
public void testAcceptSuggestionInNoTextChannel() {
Long suggestionId = 5L;
setupForNoTextChannel(suggestionId);
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
setupForNoTextChannel();
testUnit.acceptSuggestion(SUGGESTION_ID, CLOSING_TEXT, SuggestionLog.builder().build());
}
private void setupForNoTextChannel(Long suggestionId) {
AServer server = MockUtils.getServer();
Long channelId = 5L;
private void setupForNoTextChannel() {
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)
.id(SUGGESTION_ID)
.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(expected = GuildNotFoundException.class)
public void testAcceptSuggestionInNoGuild() {
Long suggestionId = 5L;
setupForNoGuild(suggestionId);
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
when(server.getId()).thenReturn(SERVER_ID);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(botService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenThrow(new ChannelNotFoundException(CHANNEL_ID));
when(suggestionManagementService.getSuggestion(SUGGESTION_ID)).thenReturn(Optional.of(suggestionToAccept));
}
@Test(expected = SuggestionUpdateException.class)
@@ -169,7 +169,6 @@ public class SuggestionServiceBeanTest {
@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");
@@ -185,15 +184,13 @@ public class SuggestionServiceBeanTest {
@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());
when(suggestionManagementService.getSuggestion(SUGGESTION_ID)).thenReturn(Optional.empty());
testUnit.rejectSuggestion(SUGGESTION_ID, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test
@@ -203,82 +200,51 @@ public class SuggestionServiceBeanTest {
@Test(expected = ChannelNotFoundException.class)
public void testRejectSuggestionInNoTextChannel() {
Long suggestionId = setupForNoTextChannel();
testUnit.rejectSuggestion(suggestionId, CLOSING_TEXT, SuggestionLog.builder().build());
setupForNoTextChannel();
testUnit.rejectSuggestion(SUGGESTION_ID, CLOSING_TEXT, SuggestionLog.builder().build());
}
@Test(expected = GuildNotFoundException.class)
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;
private void executeAcceptWithMember(Member actualMember) {
Long messageId = 7L;
SuggestionLog logParameter = SuggestionLog.builder().build();
Suggestion suggestionToAccept = setupClosing(suggesterMember, suggestionId, channelId, messageId);
Suggestion suggestionToAccept = setupClosing(messageId);
RestAction<Message> retrievalAction = Mockito.mock(RestAction.class);
when(textChannel.retrieveMessageById(messageId)).thenReturn(retrievalAction);
Message suggestionMessage = Mockito.mock(Message.class);
when(retrievalAction.submit()).thenReturn(CompletableFuture.completedFuture(suggestionMessage));
testUnit.acceptSuggestion(suggestionId, CLOSING_TEXT, logParameter);
when(botService.getMemberInServerAsync(SERVER_ID, SUGGESTER_ID)).thenReturn(CompletableFuture.completedFuture(actualMember));
testUnit.acceptSuggestion(SUGGESTION_ID, CLOSING_TEXT, logParameter);
verify(suggestionManagementService, times(1)).setSuggestionState(suggestionToAccept, SuggestionState.ACCEPTED);
}
private void executeRejectWithMember(Member suggesterMember) {
Long suggestionId = 5L;
Long channelId = 5L;
private void executeRejectWithMember(Member actualMember) {
Long messageId = 7L;
SuggestionLog logParameter = SuggestionLog.builder().build();
Suggestion suggestionToAccept = setupClosing(suggesterMember, suggestionId, channelId, messageId);
Suggestion suggestionToAccept = setupClosing(messageId);
RestAction<Message> retrievalAction = Mockito.mock(RestAction.class);
when(textChannel.retrieveMessageById(messageId)).thenReturn(retrievalAction);
Message suggestionMessage = Mockito.mock(Message.class);
when(retrievalAction.submit()).thenReturn(CompletableFuture.completedFuture(suggestionMessage));
testUnit.rejectSuggestion(suggestionId, CLOSING_TEXT, logParameter);
when(botService.getMemberInServerAsync(SERVER_ID, SUGGESTER_ID)).thenReturn(CompletableFuture.completedFuture(actualMember));
testUnit.rejectSuggestion(SUGGESTION_ID, CLOSING_TEXT, logParameter);
verify(suggestionManagementService, times(1)).setSuggestionState(suggestionToAccept, SuggestionState.REJECTED);
}
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);
private Suggestion setupClosing(Long messageId) {
Suggestion suggestionToAccept = Suggestion
.builder()
.channel(channel)
.server(server)
.id(suggestionId)
.id(SUGGESTION_ID)
.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);
when(server.getId()).thenReturn(SERVER_ID);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(suggester.getUserReference()).thenReturn(suggesterUser);
when(suggesterUser.getId()).thenReturn(SUGGESTER_ID);
when(suggestionManagementService.getSuggestion(SUGGESTION_ID)).thenReturn(Optional.of(suggestionToAccept));
when(botService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenReturn(textChannel);
return suggestionToAccept;
}
}

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

@@ -116,7 +116,7 @@ public class ReminderManagementServiceBeanTest {
Long reminderId = 5L;
Reminder reminderToLoad = Reminder.builder().build();
when(reminderRepository.findById(reminderId)).thenReturn(Optional.of(reminderToLoad));
Optional<Reminder> returned = testUnit.loadReminder(reminderId);
Optional<Reminder> returned = testUnit.loadReminderOptional(reminderId);
Assert.assertTrue(returned.isPresent());
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminderToLoad, returnedReminder));
}
@@ -125,7 +125,7 @@ public class ReminderManagementServiceBeanTest {
public void testLoadingReminderNotFound() {
Long reminderId = 5L;
when(reminderRepository.findById(reminderId)).thenReturn(Optional.empty());
Optional<Reminder> returned = testUnit.loadReminder(reminderId);
Optional<Reminder> returned = testUnit.loadReminderOptional(reminderId);
Assert.assertFalse(returned.isPresent());
}

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

@@ -18,6 +18,7 @@ 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.*;
@@ -108,11 +109,11 @@ public class StarboardPostReactorManagementServiceBeanTest {
StarStatsUser user1 = Mockito.mock(StarStatsUser.class);
StarStatsUser user2 = Mockito.mock(StarStatsUser.class);
setupStarStatsReceiverResult(amountToRetrieve, serverId, user1, user2);
List<StarStatsUser> starStatsUsers = testUnit.retrieveTopStarReceiver(serverId, amountToRetrieve);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.retrieveTopStarReceiver(serverId, amountToRetrieve);
Assert.assertEquals(expectedAmount, starStatsUsers.size());
Assert.assertEquals(user1, starStatsUsers.get(0));
Assert.assertEquals(user1, starStatsUsers.get(0).join());
if(amountToRetrieve > 1) {
Assert.assertEquals(user2, starStatsUsers.get(1));
Assert.assertEquals(user2, starStatsUsers.get(1).join());
}
}
@@ -121,11 +122,11 @@ public class StarboardPostReactorManagementServiceBeanTest {
StarStatsUser user1 = Mockito.mock(StarStatsUser.class);
StarStatsUser user2 = Mockito.mock(StarStatsUser.class);
setupStarStatsGiverResult(amountToRetrieve, serverId, user1, user2);
List<StarStatsUser> starStatsUsers = testUnit.retrieveTopStarGiver(serverId, amountToRetrieve);
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.retrieveTopStarGiver(serverId, amountToRetrieve);
Assert.assertEquals(expectedAmount, starStatsUsers.size());
Assert.assertEquals(user1, starStatsUsers.get(0));
Assert.assertEquals(user1, starStatsUsers.get(0).join());
if(amountToRetrieve > 1) {
Assert.assertEquals(user2, starStatsUsers.get(1));
Assert.assertEquals(user2, starStatsUsers.get(1).join());
}
}
@@ -134,10 +135,10 @@ public class StarboardPostReactorManagementServiceBeanTest {
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);
List<CompletableFuture<StarStatsUser>> statsUser = new ArrayList<>();
statsUser.add(CompletableFuture.completedFuture(user1));
if (amountToRetrieve > 1) {
statsUser.add(user2);
statsUser.add(CompletableFuture.completedFuture(user2));
}
when(converter.convertToStarStatsUser(results, serverId)).thenReturn(statsUser);
}
@@ -147,10 +148,10 @@ public class StarboardPostReactorManagementServiceBeanTest {
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);
List<CompletableFuture<StarStatsUser>> statsUser = new ArrayList<>();
statsUser.add(CompletableFuture.completedFuture(user1));
if (amountToRetrieve > 1) {
statsUser.add(user2);
statsUser.add(CompletableFuture.completedFuture(user2));
}
when(converter.convertToStarStatsUser(results, serverId)).thenReturn(statsUser);
}