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

[AB-184] adding various metrics to the system, organizing imports, changing some transactional behaviour

Browse Source 
adding okhttp metrics, split bot service into multiple services (guild, message), unified some places that services are used in order to interact with the api, and not directly the objects (this is to make it easier for metric to be accurate)
This commit is contained in:
Sheldan
2021-01-29 17:46:41 +01:00
parent 2a2a3aea70
commit b838678c15
362 changed files with 3045 additions and 1573 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -54,6 +54,12 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>dev.sheldan.abstracto.core</groupId>
<artifactId>metrics-interface</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</project>

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

@@ -5,7 +5,9 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.utils.FutureUtils;

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

@@ -2,11 +2,11 @@ package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.UtilityModuleInterface;
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.utils.FutureUtils;

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

@@ -9,8 +9,8 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.UserInfoModel;
@@ -32,7 +32,7 @@ public class UserInfo extends AbstractConditionableCommand {
private ChannelService channelService;
@Autowired
private BotService botService;
private MemberService memberService;
@Autowired
private UserInfo self;
@@ -44,7 +44,7 @@ public class UserInfo extends AbstractConditionableCommand {
UserInfoModel model = (UserInfoModel) ContextConverter.slimFromCommandContext(commandContext, UserInfoModel.class);
if(!memberToShow.hasTimeJoined()) {
log.info("Force reloading member {} in guild {} for user info.", memberToShow.getId(), memberToShow.getGuild().getId());
return botService.forceReloadMember(memberToShow).thenCompose(member -> {
return memberService.forceReloadMember(memberToShow).thenCompose(member -> {
model.setMemberInfo(member);
return self.sendResponse(commandContext, model)
.thenApply(aVoid -> CommandResult.fromIgnored());

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

@@ -5,7 +5,9 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.ChannelService;
@@ -44,7 +46,7 @@ public class Remind extends AbstractConditionableCommand {
List<Object> parameters = commandContext.getParameters().getParameters();
Duration remindTime = (Duration) parameters.get(0);
String text = (String) parameters.get(1);
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
ReminderModel remindModel = (ReminderModel) ContextConverter.fromCommandContext(commandContext, ReminderModel.class);
remindModel.setRemindText(text);
Reminder createdReminder = remindService.createReminderInForUser(aUserInAServer, text, remindTime, commandContext.getMessage());

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

@@ -39,7 +39,7 @@ public class Reminders extends AbstractConditionableCommand {
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
List<Reminder> activeReminders = reminderManagementService.getActiveRemindersForUser(aUserInAServer);
RemindersModel model = (RemindersModel) ContextConverter.fromCommandContext(commandContext, RemindersModel.class);
model.setReminders(activeReminders);

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

@@ -34,7 +34,7 @@ public class UnRemind extends AbstractConditionableCommand {
@Override
public CommandResult execute(CommandContext commandContext) {
Long reminderId = (Long) commandContext.getParameters().getParameters().get(0);
reminderService.unRemind(reminderId, userInServerManagementService.loadUser(commandContext.getAuthor()));
reminderService.unRemind(reminderId, userInServerManagementService.loadOrCreateUser(commandContext.getAuthor()));
return CommandResult.fromSuccess();
}

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

@@ -32,7 +32,7 @@ public class PurgeImagePosts extends AbstractConditionableCommand {
List<Object> parameters = commandContext.getParameters().getParameters();
if(!parameters.isEmpty()) {
AUserInAServer fakeUser = (AUserInAServer) parameters.get(0);
AUserInAServer actualUser = userInServerManagementService.loadUser(fakeUser.getUserInServerId());
AUserInAServer actualUser = userInServerManagementService.loadOrCreateUser(fakeUser.getUserInServerId());
postedImageService.purgePostedImages(actualUser);
} else {
postedImageService.purgePostedImages(commandContext.getGuild());

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

@@ -32,7 +32,7 @@ public class PurgeReposts extends AbstractConditionableCommand {
List<Object> parameters = commandContext.getParameters().getParameters();
if(!parameters.isEmpty()) {
AUserInAServer fakeUser = (AUserInAServer) parameters.get(0);
AUserInAServer actualUser = userInServerManagementService.loadUser(fakeUser.getUserInServerId());
AUserInAServer actualUser = userInServerManagementService.loadOrCreateUser(fakeUser.getUserInServerId());
repostService.purgeReposts(actualUser);
} else {
repostService.purgeReposts(commandContext.getGuild());

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

@@ -55,7 +55,7 @@ public class RepostLeaderboard extends AbstractConditionableCommand {
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
List<Object> parameters = commandContext.getParameters().getParameters();
Integer page = !parameters.isEmpty() ? (Integer) parameters.get(0) : 1;
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
List<RepostLeaderboardResult> topRepostingUsersOfServer = repostManagementService.findTopRepostingUsersOfServer(commandContext.getGuild().getIdLong(), page, 5);
RepostLeaderboardResult resultOfUser = repostManagementService.getRepostRankOfUser(aUserInAServer);
CompletableFuture<List<RepostLeaderboardEntryModel>> leaderBoardFuture = converter.fromLeaderBoardResults(topRepostingUsersOfServer);

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

@@ -2,12 +2,14 @@ package dev.sheldan.abstracto.utility.commands.suggest;
import dev.sheldan.abstracto.core.command.UtilityModuleInterface;
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.ParameterValidator;
import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValidator;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;

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

@@ -2,12 +2,14 @@ package dev.sheldan.abstracto.utility.commands.suggest;
import dev.sheldan.abstracto.core.command.UtilityModuleInterface;
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.ParameterValidator;
import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValidator;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;

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

@@ -2,10 +2,12 @@ package dev.sheldan.abstracto.utility.commands.suggest;
import dev.sheldan.abstracto.core.command.UtilityModuleInterface;
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;

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

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.utility.converter;
import dev.sheldan.abstracto.core.models.FullChannel;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.utility.models.database.RepostCheckChannelGroup;
import dev.sheldan.abstracto.utility.models.template.commands.RepostCheckChannelGroupDisplayModel;
import dev.sheldan.abstracto.utility.models.template.commands.RepostCheckChannelsModel;
@@ -17,7 +17,7 @@ import java.util.stream.Collectors;
public class RepostCheckChannelModelConverter {
@Autowired
private BotService botService;
private ChannelService channelService;
public RepostCheckChannelsModel fromRepostCheckChannelGroups(List<RepostCheckChannelGroup> channelGroups, Guild guild) {
List<RepostCheckChannelGroupDisplayModel> repostCheckChannelGroups = new ArrayList<>();
@@ -26,7 +26,7 @@ public class RepostCheckChannelModelConverter {
FullChannel
.builder()
.channel(channel)
.serverChannel(botService.getTextChannelFromServerNullable(guild, channel.getId()))
.serverChannel(channelService.getTextChannelFromServerNullable(guild, channel.getId()))
.build()
).collect(Collectors.toList());
repostCheckChannelGroups.add(

10
abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/converter/RepostLeaderBoardConverter.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.utility.converter;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.utility.models.RepostLeaderboardEntryModel;
@@ -23,7 +23,7 @@ public class RepostLeaderBoardConverter {
private UserInServerManagementService userInServerManagementService;
@Autowired
private BotService botService;
private MemberService memberService;
@Autowired
private RepostLeaderBoardConverter self;
@@ -40,11 +40,11 @@ public class RepostLeaderBoardConverter {
}
public CompletableFuture<RepostLeaderboardEntryModel> convertSingleUser(RepostLeaderboardResult result) {
AUserInAServer user = userInServerManagementService.loadUser(result.getUserInServerId());
AUserInAServer user = userInServerManagementService.loadOrCreateUser(result.getUserInServerId());
Integer count = result.getRepostCount();
Long userInServerId = result.getUserInServerId();
Integer rank = result.getRank();
return botService.getMemberInServerAsync(user).thenApply(member ->
return memberService.getMemberInServerAsync(user).thenApply(member ->
self.loadUserFromDatabase(member, count, userInServerId, rank)
);
}
@@ -54,7 +54,7 @@ public class RepostLeaderBoardConverter {
return RepostLeaderboardEntryModel
.builder()
.member(member)
.user(userInServerManagementService.loadUser(userInServerId))
.user(userInServerManagementService.loadOrCreateUser(userInServerId))
.count(count)
.rank(rank)
.build();

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

@@ -2,11 +2,15 @@ package dev.sheldan.abstracto.utility.listener.embed;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.config.ListenerPriority;
import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
import dev.sheldan.abstracto.core.execution.result.ExecutionResult;
import dev.sheldan.abstracto.core.execution.result.MessageReceivedListenerResult;
import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
import dev.sheldan.abstracto.core.metrics.service.CounterMetric;
import dev.sheldan.abstracto.core.metrics.service.MetricService;
import dev.sheldan.abstracto.core.metrics.service.MetricTag;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.models.MessageEmbedLink;
@@ -19,6 +23,8 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
@@ -38,13 +44,27 @@ public class MessageEmbedListener implements MessageReceivedListener {
@Autowired
private MessageEmbedListener self;
@Autowired
private MetricService metricService;
@Autowired
private MessageService messageService;
public static final String MESSAGE_EMBEDDED = "message.embedded";
public static final String MESSAGE_EMBED_ACTION = "action";
private static final CounterMetric MESSAGE_EMBED_CREATED = CounterMetric
.builder()
.name(MESSAGE_EMBEDDED)
.tagList(Arrays.asList(MetricTag.getTag(MESSAGE_EMBED_ACTION, "created")))
.build();
@Override
public MessageReceivedListenerResult execute(Message message) {
String messageRaw = message.getContentRaw();
List<MessageEmbedLink> links = messageEmbedService.getLinksInMessage(messageRaw);
if(!links.isEmpty()) {
log.trace("We found {} links to embed in message {} in channel {} in guild {}.", links.size(), message.getId(), message.getChannel().getId(), message.getGuild().getId());
Long userEmbeddingUserInServerId = userInServerManagementService.loadUser(message.getMember()).getUserInServerId();
Long userEmbeddingUserInServerId = userInServerManagementService.loadOrCreateUser(message.getMember()).getUserInServerId();
for (MessageEmbedLink messageEmbedLink : links) {
if(!messageEmbedLink.getServerId().equals(message.getGuild().getIdLong())) {
log.info("Link for message {} was from a foreign server {}. Do not embed.", messageEmbedLink.getMessageId(), messageEmbedLink.getServerId());
@@ -61,7 +81,7 @@ public class MessageEmbedListener implements MessageReceivedListener {
}
}
if(StringUtils.isBlank(messageRaw) && !links.isEmpty()) {
message.delete().queue();
messageService.deleteMessage(message);
return MessageReceivedListenerResult.DELETED;
}
if(!links.isEmpty()) {
@@ -74,7 +94,9 @@ public class MessageEmbedListener implements MessageReceivedListener {
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).exceptionally(throwable -> {
messageEmbedService.embedLink(cachedMessage, message.getTextChannel(), cause , message).thenAccept(unused ->
metricService.incrementCounter(MESSAGE_EMBED_CREATED)
).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;
@@ -95,4 +117,9 @@ public class MessageEmbedListener implements MessageReceivedListener {
public Integer getPriority() {
return ListenerPriority.MEDIUM;
}
@PostConstruct
public void postConstruct() {
metricService.registerCounter(MESSAGE_EMBED_CREATED, "Message embeds created");
}
}

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

@@ -2,6 +2,9 @@ package dev.sheldan.abstracto.utility.listener.embed;
import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.listener.async.jda.AsyncReactionAddedListener;
import dev.sheldan.abstracto.core.metrics.service.CounterMetric;
import dev.sheldan.abstracto.core.metrics.service.MetricService;
import dev.sheldan.abstracto.core.metrics.service.MetricTag;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReactions;
@@ -16,8 +19,13 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.Optional;
import static dev.sheldan.abstracto.utility.listener.embed.MessageEmbedListener.MESSAGE_EMBEDDED;
import static dev.sheldan.abstracto.utility.listener.embed.MessageEmbedListener.MESSAGE_EMBED_ACTION;
@Component
@Slf4j
public class MessageEmbedRemovalReactionListener implements AsyncReactionAddedListener {
@@ -36,6 +44,22 @@ public class MessageEmbedRemovalReactionListener implements AsyncReactionAddedLi
@Autowired
private EmoteService emoteService;
@Autowired
private MetricService metricService;
private static final CounterMetric MESSAGE_EMBED_REMOVED_CREATOR = CounterMetric
.builder()
.name(MESSAGE_EMBEDDED)
.tagList(Arrays.asList(MetricTag.getTag(MESSAGE_EMBED_ACTION, "removed.creator")))
.build();
private static final CounterMetric MESSAGE_EMBED_REMOVED_SOURCE = CounterMetric
.builder()
.name(MESSAGE_EMBEDDED)
.tagList(Arrays.asList(MetricTag.getTag(MESSAGE_EMBED_ACTION, "removed.source")))
.build();
@Override
public void executeReactionAdded(CachedMessage message, CachedReactions cachedReaction, ServerUser serverUser) {
Long guildId = message.getServerId();
@@ -44,13 +68,18 @@ public class MessageEmbedRemovalReactionListener implements AsyncReactionAddedLi
Optional<EmbeddedMessage> embeddedMessageOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(message.getMessageId());
if(embeddedMessageOptional.isPresent()) {
EmbeddedMessage embeddedMessage = embeddedMessageOptional.get();
if(embeddedMessage.getEmbeddedUser().getUserReference().getId().equals(serverUser.getUserId())
|| embeddedMessage.getEmbeddingUser().getUserReference().getId().equals(serverUser.getUserId())
) {
boolean embeddedUserRemoves = embeddedMessage.getEmbeddedUser().getUserReference().getId().equals(serverUser.getUserId());
boolean embeddingUserRemoves = embeddedMessage.getEmbeddingUser().getUserReference().getId().equals(serverUser.getUserId());
if(embeddedUserRemoves || embeddingUserRemoves) {
log.info("Removing embed in message {} in channel {} in server {} because of a user reaction.", message.getMessageId(), message.getChannelId(), message.getServerId());
messageService.deleteMessageInChannelInServer(message.getServerId(), message.getChannelId(), message.getMessageId()).thenAccept(aVoid ->{
messageService.deleteMessageInChannelInServer(message.getServerId(), message.getChannelId(), message.getMessageId()).thenAccept(aVoid -> {
Optional<EmbeddedMessage> innerOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(message.getMessageId());
innerOptional.ifPresent(value -> messageEmbedPostManagementService.deleteEmbeddedMessage(value));
if(embeddedUserRemoves) {
metricService.incrementCounter(MESSAGE_EMBED_REMOVED_SOURCE);
} else {
metricService.incrementCounter(MESSAGE_EMBED_REMOVED_CREATOR);
}
});
} else {
log.trace("Somebody besides the original author and the user embedding added the removal reaction to the message {} in channel {} in server {}.",
@@ -68,4 +97,10 @@ public class MessageEmbedRemovalReactionListener implements AsyncReactionAddedLi
return UtilityFeature.LINK_EMBEDS;
}
@PostConstruct
public void postConstruct() {
metricService.registerCounter(MESSAGE_EMBED_REMOVED_CREATOR, "Message embeds which are created by the embedding user.");
metricService.registerCounter(MESSAGE_EMBED_REMOVED_SOURCE, "Message embeds which are created by the embedded user.");
}
}

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

@@ -4,7 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageEmbeddedListener;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.listener.GuildMessageEmbedEventModel;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.utility.config.features.UtilityFeature;
import dev.sheldan.abstracto.utility.service.RepostCheckChannelService;
@@ -36,7 +36,7 @@ public class RepostEmbedListener implements AsyncMessageEmbeddedListener {
private ChannelManagementService channelManagementService;
@Autowired
private BotService botService;
private ChannelService channelService;
@Override
public void execute(GuildMessageEmbedEventModel eventModel) {
@@ -47,9 +47,11 @@ public class RepostEmbedListener implements AsyncMessageEmbeddedListener {
eventModel.getMessageId(), eventModel.getChannelId(), eventModel.getServerId());
return;
}
botService.getTextChannelFromServer(eventModel.getServerId(), eventModel.getChannelId()).retrieveMessageById(eventModel.getMessageId()).queue(message -> {
channelService.retrieveMessageInChannel(eventModel.getServerId(), eventModel.getChannelId(), eventModel.getMessageId()).thenAccept(message -> {
List<MessageEmbed> imageEmbeds = eventModel.getEmbeds().stream().filter(messageEmbed -> messageEmbed.getType().equals(EmbedType.IMAGE)).collect(Collectors.toList());
repostService.processMessageEmbedsRepostCheck(imageEmbeds, message);
if(!imageEmbeds.isEmpty()) {
repostService.processMessageEmbedsRepostCheck(imageEmbeds, message);
}
});
}
}

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

@@ -4,6 +4,9 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
import dev.sheldan.abstracto.core.listener.async.jda.AsyncReactionAddedListener;
import dev.sheldan.abstracto.core.listener.async.jda.AsyncReactionClearedListener;
import dev.sheldan.abstracto.core.listener.async.jda.AsyncReactionRemovedListener;
import dev.sheldan.abstracto.core.metrics.service.CounterMetric;
import dev.sheldan.abstracto.core.metrics.service.MetricService;
import dev.sheldan.abstracto.core.metrics.service.MetricTag;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReactions;
@@ -23,6 +26,8 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
@@ -56,6 +61,36 @@ public class StarboardListener implements AsyncReactionAddedListener, AsyncReact
@Autowired
private EmoteService emoteService;
@Autowired
private MetricService metricService;
public static final String STARBOARD_STARS = "starboard.stars";
public static final String STARBOARD_POSTS = "starboard.posts";
public static final String STAR_ACTION = "action";
private static final CounterMetric STARBOARD_STARS_ADDED = CounterMetric
.builder()
.name(STARBOARD_STARS)
.tagList(Arrays.asList(MetricTag.getTag(STAR_ACTION, "added")))
.build();
private static final CounterMetric STARBOARD_STARS_REMOVED = CounterMetric
.builder()
.name(STARBOARD_STARS)
.tagList(Arrays.asList(MetricTag.getTag(STAR_ACTION, "removed")))
.build();
private static final CounterMetric STARBOARD_STARS_THRESHOLD_REACHED = CounterMetric
.builder()
.name(STARBOARD_POSTS)
.tagList(Arrays.asList(MetricTag.getTag(STAR_ACTION, "threshold.reached")))
.build();
private static final CounterMetric STARBOARD_STARS_THRESHOLD_FELL = CounterMetric
.builder()
.name(STARBOARD_POSTS)
.tagList(Arrays.asList(MetricTag.getTag(STAR_ACTION, "threshold.below")))
.build();
@Override
@Transactional
public void executeReactionAdded(CachedMessage message, CachedReactions cachedReaction, ServerUser serverUser) {
@@ -65,6 +100,7 @@ public class StarboardListener implements AsyncReactionAddedListener, AsyncReact
Long guildId = message.getServerId();
AEmote aEmote = emoteService.getEmoteOrDefaultEmote(STAR_EMOTE, guildId);
if(emoteService.compareCachedEmoteWithAEmote(cachedReaction.getEmote(), aEmote)) {
metricService.incrementCounter(STARBOARD_STARS_ADDED);
log.info("User {} in server {} reacted with star to put a message {} from channel {} on starboard.", serverUser.getUserId(), message.getServerId(), message.getMessageId(), message.getChannelId());
Optional<CachedReactions> reactionOptional = emoteService.getReactionFromMessageByEmote(message, aEmote);
handleStarboardPostChange(message, reactionOptional.orElse(null), serverUser, true);
@@ -74,21 +110,23 @@ public class StarboardListener implements AsyncReactionAddedListener, AsyncReact
private void handleStarboardPostChange(CachedMessage message, CachedReactions reaction, ServerUser serverUser, boolean adding) {
Optional<StarboardPost> starboardPostOptional = starboardPostManagementService.findByMessageId(message.getMessageId());
if(reaction != null) {
AUserInAServer author = userInServerManagementService.loadUser(message.getServerId(), message.getAuthor().getAuthorId());
AUserInAServer author = userInServerManagementService.loadOrCreateUser(message.getServerId(), message.getAuthor().getAuthorId());
List<AUserInAServer> userExceptAuthor = getUsersExcept(reaction.getUsers(), author);
Long starMinimum = getFromConfig(FIRST_LEVEL_THRESHOLD_KEY, message.getServerId());
AUserInAServer userAddingReaction = userInServerManagementService.loadUser(serverUser);
AUserInAServer userAddingReaction = userInServerManagementService.loadOrCreateUser(serverUser);
if (userExceptAuthor.size() >= starMinimum) {
log.info("Post reached starboard minimum. Message {} in channel {} in server {} will be starred/updated.",
message.getMessageId(), message.getChannelId(), message.getServerId());
if(starboardPostOptional.isPresent()) {
updateStarboardPost(message, userAddingReaction, adding, starboardPostOptional.get(), userExceptAuthor);
} else {
metricService.incrementCounter(STARBOARD_STARS_THRESHOLD_REACHED);
log.info("Creating starboard post for message {} in channel {} in server {}", message.getMessageId(), message.getChannelId(), message.getServerId());
starboardService.createStarboardPost(message, userExceptAuthor, userAddingReaction, author);
}
} else {
if(starboardPostOptional.isPresent()) {
metricService.incrementCounter(STARBOARD_STARS_THRESHOLD_FELL);
log.info("Removing starboard post for message {} in channel {} in server {}. It fell under the threshold {}", message.getMessageId(), message.getChannelId(), message.getServerId(), starMinimum);
starboardPostOptional.ifPresent(this::completelyRemoveStarboardPost);
}
@@ -128,6 +166,7 @@ public class StarboardListener implements AsyncReactionAddedListener, AsyncReact
Long guildId = message.getServerId();
AEmote aEmote = emoteService.getEmoteOrDefaultEmote(STAR_EMOTE, guildId);
if(emoteService.compareCachedEmoteWithAEmote(removedReaction.getEmote(), aEmote)) {
metricService.incrementCounter(STARBOARD_STARS_REMOVED);
log.info("User {} in server {} removed star reaction from message {} on starboard.",
userRemoving.getUserId(), message.getServerId(), message.getMessageId());
Optional<CachedReactions> reactionOptional = emoteService.getReactionFromMessageByEmote(message, aEmote);
@@ -163,4 +202,12 @@ public class StarboardListener implements AsyncReactionAddedListener, AsyncReact
});
}
@PostConstruct
public void postConstruct() {
metricService.registerCounter(STARBOARD_STARS_ADDED, "Star reaction added");
metricService.registerCounter(STARBOARD_STARS_REMOVED, "Star reaction removed");
metricService.registerCounter(STARBOARD_STARS_THRESHOLD_REACHED, "Starboard posts reaching threshold");
metricService.registerCounter(STARBOARD_STARS_THRESHOLD_FELL, "Starboard posts falling below threshold");
}
}

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

@@ -2,7 +2,7 @@ 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.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;
@@ -17,7 +17,7 @@ import java.util.concurrent.CompletableFuture;
public class StarStatsUserConverter {
@Autowired
private BotService botService;
private MemberService memberService;
@Autowired
private UserInServerManagementService userInServerManagementService;
@@ -31,8 +31,8 @@ public class StarStatsUserConverter {
}
private CompletableFuture<StarStatsUser> createStarStatsUser(Long serverId, StarStatsUserResult starStatsUserResult) {
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(starStatsUserResult.getUserId());
return botService.getMemberInServerAsync(serverId, aUserInAServer.getUserReference().getId()).thenApply(member ->
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(starStatsUserResult.getUserId());
return memberService.getMemberInServerAsync(serverId, aUserInAServer.getUserReference().getId()).thenApply(member ->
StarStatsUser
.builder()
.starCount(starStatsUserResult.getStarCount())

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

@@ -1,16 +1,13 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.models.template.listener.MessageEmbeddedModel;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.service.MessageService;
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.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;
@@ -49,7 +46,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
private UserInServerManagementService userInServerManagementService;
@Autowired
private BotService botService;
private MemberService memberService;
@Autowired
private TemplateService templateService;
@@ -67,7 +64,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
private MessageEmbedPostManagementService messageEmbedPostManagementService;
@Autowired
private MessageService messageService;
private ReactionService reactionService;
@Override
public List<MessageEmbedLink> getLinksInMessage(String message) {
@@ -123,14 +120,14 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
@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);
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 messageService.addReactionToMessageWithFuture(REMOVAL_EMOTE, cachedMessage.getServerId(), createdMessage).thenAccept(aVoid1 ->
return reactionService.addReactionToMessageAsync(REMOVAL_EMOTE, cachedMessage.getServerId(), createdMessage).thenAccept(aVoid1 ->
self.loadUserAndPersistMessage(cachedMessage, userInServerId, createdMessage)
);
});
@@ -138,19 +135,19 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
@Transactional
public void loadUserAndPersistMessage(CachedMessage cachedMessage, Long userInServerId, Message createdMessage) {
AUserInAServer innerCause = userInServerManagementService.loadUser(userInServerId);
AUserInAServer innerCause = userInServerManagementService.loadOrCreateUser(userInServerId);
messageEmbedPostManagementService.createMessageEmbed(cachedMessage, createdMessage, innerCause);
}
private CompletableFuture<MessageEmbeddedModel> buildTemplateParameter(Message message, CachedMessage embeddedMessage) {
return botService.getMemberInServerAsync(embeddedMessage.getServerId(), embeddedMessage.getAuthor().getAuthorId()).thenApply(member ->
return memberService.getMemberInServerAsync(embeddedMessage.getServerId(), embeddedMessage.getAuthor().getAuthorId()).thenApply(member ->
self.loadMessageEmbedModel(message, embeddedMessage, member)
);
}
@Transactional
public MessageEmbeddedModel loadMessageEmbedModel(Message message, CachedMessage embeddedMessage, Member member) {
Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServerOptional(embeddedMessage.getServerId(), embeddedMessage.getChannelId());
Optional<TextChannel> textChannelFromServer = channelService.getTextChannelFromServerOptional(embeddedMessage.getServerId(), embeddedMessage.getChannelId());
TextChannel sourceChannel = textChannelFromServer.orElse(null);
return MessageEmbeddedModel
.builder()

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

@@ -1,15 +1,16 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.service.ChannelService;
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.AUserInAServer;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.GuildService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.scheduling.service.SchedulerService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.exception.ReminderNotFoundException;
import dev.sheldan.abstracto.utility.models.database.Reminder;
@@ -30,7 +31,9 @@ import java.time.Duration;
import java.time.Instant;
import java.util.Date;
import java.util.Optional;
import java.util.concurrent.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Component
@Slf4j
@@ -50,7 +53,10 @@ public class RemindServiceBean implements ReminderService {
private SchedulerService schedulerService;
@Autowired
private BotService botService;
private MemberService memberService;
@Autowired
private GuildService guildService;
@Autowired
private RemindServiceBean self;
@@ -109,12 +115,12 @@ 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.getGuildByIdOptional(server.getId());
Optional<Guild> guildToAnswerIn = guildService.getGuildByIdOptional(server.getId());
if(guildToAnswerIn.isPresent()) {
Optional<TextChannel> channelToAnswerIn = botService.getTextChannelFromServerOptional(server.getId(), channel.getId());
Optional<TextChannel> channelToAnswerIn = channelService.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()) {
botService.getMemberInServerAsync(server.getId(), reminderToRemindFor.getRemindedUser().getUserReference().getId()).thenAccept(member ->
memberService.getMemberInServerAsync(server.getId(), reminderToRemindFor.getRemindedUser().getUserReference().getId()).thenAccept(member ->
self.sendReminderText(reminderId, channelToAnswerIn.get(), member)
);

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

@@ -7,10 +7,7 @@ import dev.sheldan.abstracto.core.models.cache.CachedEmbed;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.FeatureModeService;
import dev.sheldan.abstracto.core.service.HashService;
import dev.sheldan.abstracto.core.service.HttpService;
import dev.sheldan.abstracto.core.service.MessageService;
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;
@@ -25,7 +22,9 @@ import dev.sheldan.abstracto.utility.models.database.result.RepostLeaderboardRes
import dev.sheldan.abstracto.utility.service.management.PostedImageManagement;
import dev.sheldan.abstracto.utility.service.management.RepostManagementService;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageEmbed;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@@ -64,7 +63,7 @@ public class RepostServiceBean implements RepostService {
private UserInServerManagementService userInServerManagementService;
@Autowired
private MessageService messageService;
private ReactionService reactionService;
@Autowired
private FeatureModeService featureModeService;
@@ -143,7 +142,7 @@ public class RepostServiceBean implements RepostService {
PostedImage existingRepost = potentialRepost.get();
return !existingRepost.getPostId().getMessageId().equals(serverChannelMessageUser.getMessageId()) ? Optional.of(existingRepost) : Optional.empty();
} else {
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(serverChannelMessageUser.getServerId(), serverChannelMessageUser.getUserId());
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(serverChannelMessageUser.getServerId(), serverChannelMessageUser.getUserId());
AServerAChannelAUser cause = AServerAChannelAUser
.builder()
.aUserInAServer(aUserInAServer)
@@ -219,10 +218,10 @@ public class RepostServiceBean implements RepostService {
private void markMessageAndPersist(ServerChannelMessageUser messageUser, Integer index, boolean moreRepostsPossible, PostedImage originalPost) {
log.info("Detected repost in message embed {} of message {} in channel {} in server {}.", index, messageUser.getMessageId(), messageUser.getChannelId(), messageUser.getServerId());
CompletableFuture<Void> markerFuture = messageService.addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, messageUser.getServerId(), messageUser.getChannelId(), messageUser.getMessageId());
CompletableFuture<Void> markerFuture = reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, messageUser.getServerId(), messageUser.getChannelId(), messageUser.getMessageId());
CompletableFuture<Void> counterFuture;
if (moreRepostsPossible) {
counterFuture = messageService.addDefaultReactionToMessageAsync(NUMBER_EMOJI.get(index), messageUser.getServerId(), messageUser.getChannelId(), messageUser.getMessageId());
counterFuture = reactionService.addDefaultReactionToMessageAsync(NUMBER_EMOJI.get(index), messageUser.getServerId(), messageUser.getChannelId(), messageUser.getMessageId());
} else {
counterFuture = CompletableFuture.completedFuture(null);
}
@@ -238,7 +237,7 @@ public class RepostServiceBean implements RepostService {
@Transactional
public void persistRepost(Long messageId, Integer position, Long serverId, Long userId) {
PostedImage postedImage = postedImageManagement.getPostFromMessageAndPosition(messageId, position);
AUserInAServer userInAServer = userInServerManagementService.loadUser(serverId, userId);
AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(serverId, userId);
Optional<Repost> existingPost = repostManagementService.findRepostOptional(postedImage, userInAServer);
if(existingPost.isPresent()) {
Repost previousRepost = existingPost.get();

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

@@ -1,19 +1,19 @@
package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.exception.UserInServerNotFoundException;
import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.models.database.PostTarget;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.core.service.management.PostTargetManagement;
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;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.PostTargetService;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.config.posttargets.StarboardPostTarget;
import dev.sheldan.abstracto.utility.models.database.StarboardPost;
@@ -24,7 +24,9 @@ import dev.sheldan.abstracto.utility.models.template.commands.starboard.Starboar
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.*;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@@ -46,7 +48,13 @@ public class StarboardServiceBean implements StarboardService {
public static final String STAR_LEVELS_CONFIG_KEY = "starLvls";
@Autowired
private BotService botService;
private MemberService memberService;
@Autowired
private GuildService guildService;
@Autowired
private ChannelService channelService;
@Autowired
private PostTargetService postTargetService;
@@ -78,6 +86,9 @@ public class StarboardServiceBean implements StarboardService {
@Autowired
private DefaultConfigManagementService defaultConfigManagementService;
@Autowired
private MessageService messageService;
@Autowired
private StarboardServiceBean self;
@@ -125,9 +136,9 @@ public class StarboardServiceBean implements StarboardService {
}
private CompletableFuture<StarboardPostModel> buildStarboardPostModel(CachedMessage message, Integer starCount) {
return botService.getMemberInServerAsync(message.getServerId(), message.getAuthor().getAuthorId()).thenApply(member -> {
Optional<TextChannel> channel = botService.getTextChannelFromServerOptional(message.getServerId(), message.getChannelId());
Optional<Guild> guild = botService.getGuildByIdOptional(message.getServerId());
return memberService.getMemberInServerAsync(message.getServerId(), message.getAuthor().getAuthorId()).thenApply(member -> {
Optional<TextChannel> channel = channelService.getTextChannelFromServerOptional(message.getServerId(), message.getChannelId());
Optional<Guild> guild = guildService.getGuildByIdOptional(message.getServerId());
// TODO use model objects instead of building entity models
AChannel aChannel = AChannel.builder().id(message.getChannelId()).build();
AUser user = AUser.builder().id(message.getAuthor().getAuthorId()).build();
@@ -165,7 +176,7 @@ public class StarboardServiceBean implements StarboardService {
public void deleteStarboardMessagePost(StarboardPost message) {
AChannel starboardChannel = message.getStarboardChannel();
log.info("Deleting starboard post {} in server {}", message.getId(), message.getSourceChanel().getServer().getId());
botService.deleteMessage(starboardChannel.getServer().getId(), starboardChannel.getId(), message.getStarboardMessageId());
messageService.deleteMessageInChannelInServer(starboardChannel.getServer().getId(), starboardChannel.getId(), message.getStarboardMessageId());
}
@Override

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

@@ -2,28 +2,27 @@ package dev.sheldan.abstracto.utility.service;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.CounterService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
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;
import dev.sheldan.abstracto.core.service.PostTargetService;
import dev.sheldan.abstracto.core.utils.MessageUtils;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.utility.config.posttargets.SuggestionPostTarget;
import dev.sheldan.abstracto.utility.exception.SuggestionNotFoundException;
import dev.sheldan.abstracto.utility.exception.SuggestionUpdateException;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.SuggestionState;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.management.SuggestionManagementService;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.TextChannel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@@ -49,10 +48,13 @@ public class SuggestionServiceBean implements SuggestionService {
private TemplateService templateService;
@Autowired
private BotService botService;
private ChannelService channelService;
@Autowired
private MessageService messageService;
private MemberService memberService;
@Autowired
private ReactionService reactionService;
@Autowired
private UserInServerManagementService userInServerManagementService;
@@ -69,7 +71,7 @@ public class SuggestionServiceBean implements SuggestionService {
@Override
public CompletableFuture<Void> createSuggestionMessage(Member member, String text, SuggestionLog suggestionLog) {
AServer server = serverManagementService.loadServer(member.getGuild());
AUserInAServer suggester = userInServerManagementService.loadUser(member);
AUserInAServer suggester = userInServerManagementService.loadOrCreateUser(member);
Long newSuggestionId = counterService.getNextCounterValue(server, SUGGESTION_COUNTER_KEY);
suggestionLog.setSuggestionId(newSuggestionId);
suggestionLog.setState(SuggestionState.NEW);
@@ -82,8 +84,8 @@ public class SuggestionServiceBean implements SuggestionService {
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);
CompletableFuture<Void> secondReaction = messageService.addReactionToMessageWithFuture(SUGGESTION_NO_EMOTE, guildId, message);
CompletableFuture<Void> firstReaction = reactionService.addReactionToMessageAsync(SUGGESTION_YES_EMOTE, guildId, message);
CompletableFuture<Void> secondReaction = reactionService.addReactionToMessageAsync(SUGGESTION_NO_EMOTE, guildId, message);
return CompletableFuture.allOf(firstReaction, secondReaction).thenAccept(aVoid1 -> {
log.trace("Reaction added to message {} for suggestion {}.", message.getId(), newSuggestionId);
self.persistSuggestionInDatabase(member, text, message, newSuggestionId);
@@ -116,8 +118,8 @@ public class SuggestionServiceBean implements SuggestionService {
suggestionLog.setOriginalMessageId(originalMessageId);
suggestionLog.setOriginalMessageUrl(MessageUtils.buildMessageUrl(serverId, channelId, originalMessageId));
AUserInAServer suggester = suggestion.getSuggester();
TextChannel textChannelById = botService.getTextChannelFromServer(serverId, channelId);
CompletableFuture<Member> memberById = botService.getMemberInServerAsync(serverId, suggester.getUserReference().getId());
TextChannel textChannelById = channelService.getTextChannelFromServer(serverId, channelId);
CompletableFuture<Member> memberById = memberService.getMemberInServerAsync(serverId, suggester.getUserReference().getId());
suggestionLog.setState(suggestion.getState());
suggestionLog.setSuggestionId(suggestion.getSuggestionId().getId());
CompletableFuture<Void> finalFuture = new CompletableFuture<>();
@@ -125,8 +127,8 @@ public class SuggestionServiceBean implements SuggestionService {
if(throwable == null) {
suggestionLog.setSuggester(member);
}
textChannelById.retrieveMessageById(originalMessageId).submit().thenCompose(message ->
self.updateSuggestionMessageText(text, suggestionLog, message)
channelService.retrieveMessageInChannel(textChannelById, originalMessageId).thenCompose(message ->
self.updateSuggestionMessageText(text, suggestionLog, message)
).thenAccept(aVoid -> finalFuture.complete(null));
});
@@ -134,7 +136,7 @@ public class SuggestionServiceBean implements SuggestionService {
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Transactional
public CompletableFuture<Void> updateSuggestionMessageText(String text, SuggestionLog suggestionLog, Message message) {
Optional<MessageEmbed> embedOptional = message.getEmbeds().stream().filter(embed -> embed.getDescription() != null).findFirst();
if(embedOptional.isPresent()) {

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

@@ -44,7 +44,7 @@ public class MessageEmbedPostManagementServiceBean implements MessageEmbedPostMa
}
AChannel embeddingChannel = channelManagementService.loadChannel(messageContainingEmbed.getChannel().getIdLong());
AChannel embeddedChannel = channelManagementService.loadChannel(embeddedMessage.getChannelId());
AUserInAServer embeddedAuthor = userInServerManagementService.loadUser(embeddedMessage.getServerId(), embeddedMessage.getAuthor().getAuthorId());
AUserInAServer embeddedAuthor = userInServerManagementService.loadOrCreateUser(embeddedMessage.getServerId(), embeddedMessage.getAuthor().getAuthorId());
EmbeddedMessage messageEmbedPost = EmbeddedMessage
.builder()
.embeddedMessageId(embeddedMessage.getMessageId())

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

@@ -1,13 +1,13 @@
package dev.sheldan.abstracto.utility.service.management;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.SuggestionState;
import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.repository.SuggestionRepository;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Member;
@@ -36,7 +36,7 @@ public class SuggestionManagementServiceBean implements SuggestionManagementServ
@Override
public Suggestion createSuggestion(Member suggester, String text, Message message, Long suggestionId) {
AUserInAServer user = userInServerManagementService.loadUser(suggester);
AUserInAServer user = userInServerManagementService.loadOrCreateUser(suggester);
return this.createSuggestion(user, text, message, suggestionId);
}

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

@@ -2,8 +2,8 @@ package dev.sheldan.abstracto.utility.commands;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.UserInfoModel;
@@ -30,7 +30,7 @@ public class UserInfoTest {
private ChannelService channelService;
@Mock
private BotService botService;
private MemberService memberService;
@Mock
private UserInfo self;
@@ -56,7 +56,7 @@ public class UserInfoTest {
when(noParameters.getAuthor().hasTimeJoined()).thenReturn(false);
Member loadedAuthor = Mockito.mock(Member.class);
when(noParameters.getAuthor().getGuild()).thenReturn(Mockito.mock(Guild.class));
when(botService.forceReloadMember(noParameters.getAuthor())).thenReturn(CompletableFuture.completedFuture(loadedAuthor));
when(memberService.forceReloadMember(noParameters.getAuthor())).thenReturn(CompletableFuture.completedFuture(loadedAuthor));
when(self.sendResponse(eq(noParameters), modelArgumentCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(noParameters);
UserInfoModel usedModel = modelArgumentCaptor.getValue();
@@ -83,7 +83,7 @@ public class UserInfoTest {
CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(member));
Member loadedAuthor = Mockito.mock(Member.class);
when(member.getGuild()).thenReturn(Mockito.mock(Guild.class));
when(botService.forceReloadMember(member)).thenReturn(CompletableFuture.completedFuture(loadedAuthor));
when(memberService.forceReloadMember(member)).thenReturn(CompletableFuture.completedFuture(loadedAuthor));
when(self.sendResponse(eq(parameters), modelArgumentCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
UserInfoModel usedModel = modelArgumentCaptor.getValue();

6
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/commands/entertainment/RollTest.java
View File

@@ -8,11 +8,13 @@ import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.utility.models.template.commands.RollResponseModel;
import dev.sheldan.abstracto.utility.service.EntertainmentService;
import net.dv8tion.jda.api.entities.Guild;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;

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

@@ -45,7 +45,7 @@ public class RemindTest {
Duration duration = Duration.ofMinutes(10);
CommandContext withParameters = CommandTestUtilities.getWithParameters(Arrays.asList(duration, reminderText));
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUser(withParameters.getAuthor())).thenReturn(user);
when(userInServerManagementService.loadOrCreateUser(withParameters.getAuthor())).thenReturn(user);
CompletableFuture<CommandResult> result = testUnit.executeAsync(withParameters);
verify(remindService, times(1)).createReminderInForUser(user, reminderText, duration, withParameters.getMessage());
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(Remind.REMINDER_EMBED_KEY), captor.capture(), eq(withParameters.getChannel()));

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

@@ -47,7 +47,7 @@ public class RemindersTest {
Reminder secondReminder = Reminder.builder().build();
List<Reminder> reminders = Arrays.asList(reminder, secondReminder);
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUser(context.getAuthor())).thenReturn(user);
when(userInServerManagementService.loadOrCreateUser(context.getAuthor())).thenReturn(user);
when(reminderManagementService.getActiveRemindersForUser(user)).thenReturn(reminders);
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(Reminders.REMINDERS_RESPONSE_TEMPLATE), modelCaptor.capture(), eq(context.getChannel()));

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

@@ -35,7 +35,7 @@ public class UnRemindTest {
Long reminderId = 6L;
CommandContext withParameters = CommandTestUtilities.getWithParameters(Arrays.asList(reminderId));
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUser(withParameters.getAuthor())).thenReturn(user);
when(userInServerManagementService.loadOrCreateUser(withParameters.getAuthor())).thenReturn(user);
CommandResult result = testUnit.execute(withParameters);
verify(reminderService, times(1)).unRemind(reminderId, user);
CommandTestUtilities.checkSuccessfulCompletion(result);

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

@@ -37,7 +37,7 @@ public class PurgeImagePostsTest {
Long userInServerId = 1L;
when(fakeUser.getUserInServerId()).thenReturn(userInServerId);
CommandContext purgeImagePostsParameters = CommandTestUtilities.getWithParameters(Arrays.asList(fakeUser));
when(userInServerManagementService.loadUser(userInServerId)).thenReturn(actualUser);
when(userInServerManagementService.loadOrCreateUser(userInServerId)).thenReturn(actualUser);
CommandResult result = testUnit.execute(purgeImagePostsParameters);
CommandTestUtilities.checkSuccessfulCompletion(result);
verify(postedImageService, times(1)).purgePostedImages(actualUser);

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

@@ -37,7 +37,7 @@ public class PurgeRepostsTest {
Long userInServerId = 1L;
when(fakeUser.getUserInServerId()).thenReturn(userInServerId);
CommandContext purgeImagePostsParameters = CommandTestUtilities.getWithParameters(Arrays.asList(fakeUser));
when(userInServerManagementService.loadUser(userInServerId)).thenReturn(actualUser);
when(userInServerManagementService.loadOrCreateUser(userInServerId)).thenReturn(actualUser);
CommandResult result = testUnit.execute(purgeImagePostsParameters);
CommandTestUtilities.checkSuccessfulCompletion(result);
verify(repostService, times(1)).purgeReposts(actualUser);

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

@@ -84,7 +84,7 @@ public class RepostLeaderboardTest {
public void executeRepostLeaderboardTest(Integer page, CommandContext noParameters) {
when(noParameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
when(userInServerManagementService.loadUser(noParameters.getAuthor())).thenReturn(aUserInAServer);
when(userInServerManagementService.loadOrCreateUser(noParameters.getAuthor())).thenReturn(aUserInAServer);
when(repostManagementService.getRepostRankOfUser(aUserInAServer)).thenReturn(userResult);
List<RepostLeaderboardResult> resultList = Arrays.asList(result);
when(repostManagementService.findTopRepostingUsersOfServer(SERVER_ID, page, 5)).thenReturn(resultList);

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

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.utility.converter;
import dev.sheldan.abstracto.core.models.FullChannel;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.utility.models.database.RepostCheckChannelGroup;
import dev.sheldan.abstracto.utility.models.template.commands.RepostCheckChannelGroupDisplayModel;
import dev.sheldan.abstracto.utility.models.template.commands.RepostCheckChannelsModel;
@@ -29,7 +29,7 @@ public class RepostCheckChannelModelConverterTest {
private RepostCheckChannelModelConverter testUnit;
@Mock
private BotService botService;
private ChannelService channelService;
@Mock
private Guild guild;
@@ -62,11 +62,11 @@ public class RepostCheckChannelModelConverterTest {
AChannel channel1 = Mockito.mock(AChannel.class);
when(channel1.getId()).thenReturn(channelId1);
TextChannel textChannel = Mockito.mock(TextChannel.class);
when(botService.getTextChannelFromServerNullable(guild, channelId1)).thenReturn(textChannel);
when(channelService.getTextChannelFromServerNullable(guild, channelId1)).thenReturn(textChannel);
Long channelId2 = 2L;
AChannel channel2 = Mockito.mock(AChannel.class);
when(channel2.getId()).thenReturn(channelId2);
when(botService.getTextChannelFromServerNullable(guild, channelId2)).thenReturn(null);
when(channelService.getTextChannelFromServerNullable(guild, channelId2)).thenReturn(null);
when(group.getChannels()).thenReturn(Arrays.asList(channel1, channel2));
RepostCheckChannelsModel model = testUnit.fromRepostCheckChannelGroups(Arrays.asList(element), guild);
Assert.assertEquals(1, model.getRepostCheckChannelGroups().size());

14
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/converter/RepostLeaderBoardConverterTest.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.utility.converter;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.utility.models.RepostLeaderboardEntryModel;
import dev.sheldan.abstracto.utility.models.database.result.RepostLeaderboardResult;
@@ -31,7 +31,7 @@ public class RepostLeaderBoardConverterTest {
private UserInServerManagementService userInServerManagementService;
@Mock
private BotService botService;
private MemberService memberService;
@Mock
private RepostLeaderBoardConverter self;
@@ -73,9 +73,9 @@ public class RepostLeaderBoardConverterTest {
Integer secondRank = RANK + 1;
when(result2.getRank()).thenReturn(secondRank);
AUserInAServer secondAUserInAServer = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUser(secondUserInServerId)).thenReturn(secondAUserInAServer);
when(userInServerManagementService.loadOrCreateUser(secondUserInServerId)).thenReturn(secondAUserInAServer);
Member secondMember = Mockito.mock(Member.class);
when(botService.getMemberInServerAsync(secondAUserInAServer)).thenReturn(CompletableFuture.completedFuture(secondMember));
when(memberService.getMemberInServerAsync(secondAUserInAServer)).thenReturn(CompletableFuture.completedFuture(secondMember));
CompletableFuture<List<RepostLeaderboardEntryModel>> future = testUnit.fromLeaderBoardResults(Arrays.asList(result, result2));
Assert.assertTrue(future.isDone());
Assert.assertEquals(2, future.join().size());
@@ -92,14 +92,14 @@ public class RepostLeaderBoardConverterTest {
when(result.getUserInServerId()).thenReturn(USER_IN_SERVER_ID);
when(result.getRepostCount()).thenReturn(REPOST_COUNT);
when(result.getRank()).thenReturn(RANK);
when(userInServerManagementService.loadUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
when(botService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(member));
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(member));
return result;
}
@Test
public void testLoadUserFromDatabase() {
when(userInServerManagementService.loadUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
RepostLeaderboardEntryModel loadedModel = testUnit.loadUserFromDatabase(member, REPOST_COUNT, USER_IN_SERVER_ID, RANK);
Assert.assertEquals(REPOST_COUNT, loadedModel.getCount());
Assert.assertEquals(RANK, loadedModel.getRank());

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.models.MessageEmbedLink;
@@ -13,7 +14,6 @@ import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import net.dv8tion.jda.internal.requests.restaction.AuditableRestActionImpl;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -46,15 +46,15 @@ public class MessageEmbedListenerTest {
@Mock
private MessageEmbedService messageEmbedService;
@Mock
private MessageService messageService;
@Mock
private MessageEmbedListener self;
@Mock
private Message message;
@Mock
private AuditableRestActionImpl<Void> deletionRestAction;
@Mock
private TextChannel textChannel;
@@ -75,7 +75,7 @@ public class MessageEmbedListenerTest {
List<MessageEmbedLink> foundMessageLinks = new ArrayList<>();
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(message, times(0)).delete();
verify(messageService, times(0)).deleteMessage(message);
}
@Test
@@ -84,8 +84,7 @@ public class MessageEmbedListenerTest {
String text = linkText;
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, ORIGIN_GUILD_ID);
verify(self, times(1)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(message, times(1)).delete();
verify(deletionRestAction, times(1)).queue();
verify(messageService, times(1)).deleteMessage(message);
}
@Test
@@ -94,8 +93,7 @@ public class MessageEmbedListenerTest {
String text = linkText + "more text";
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, ORIGIN_GUILD_ID);
verify(self, times(1)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
verify(messageService, times(0)).deleteMessage(message);
}
@Test
@@ -103,8 +101,7 @@ public class MessageEmbedListenerTest {
String linkText = "link";
String text = linkText + "more text";
executeLinkTestForOneLink(text, linkText, ORIGIN_GUILD_ID, EMBEDDING_GUILD_ID);
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
verify(messageService, times(0)).deleteMessage(message);
verify(self, times(0)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
}
@@ -142,13 +139,12 @@ public class MessageEmbedListenerTest {
when(message.getMember()).thenReturn(author);
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(EMBEDDING_GUILD_ID);
when(userInServerManagementService.loadUser(author)).thenReturn(embeddingUser);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(embeddingUser);
CachedMessage cachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(embeddingServer.getId(), embeddingChannel.getId(), secondMessageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageEmbedService.getLinksInMessage(completeMessage)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(message, times(0)).delete();
verify(deletionRestAction, times(0)).queue();
verify(messageService, times(0)).deleteMessage(message);
verify(self, times(1)).embedSingleLink(message, embeddingUser.getUserInServerId(), cachedMessage);
}
@@ -179,16 +175,14 @@ public class MessageEmbedListenerTest {
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(message.delete()).thenReturn(deletionRestAction);
when(userInServerManagementService.loadUser(author)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(userInAServer);
CachedMessage cachedMessage = CachedMessage.builder().build();
CachedMessage secondCachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(server.getId(), channel.getId(), messageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageCache.getMessageFromCache(server.getId(), channel.getId(), secondMessageId)).thenReturn(CompletableFuture.completedFuture(secondCachedMessage));
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
testUnit.execute(message);
verify(message, times(1)).delete();
verify(deletionRestAction, times(1)).queue();
verify(messageService, times(1)).deleteMessage(message);
verify(self, times(1)).embedSingleLink(message, userInAServer.getUserInServerId(), cachedMessage);
verify(self, times(1)).embedSingleLink(message, userInAServer.getUserInServerId(), secondCachedMessage);
}
@@ -219,8 +213,7 @@ public class MessageEmbedListenerTest {
List<MessageEmbedLink> foundMessageLinks = Arrays.asList(foundLink);
Member author = Mockito.mock(Member.class);
when(message.getMember()).thenReturn(author);
when(message.delete()).thenReturn(deletionRestAction);
when(userInServerManagementService.loadUser(author)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(userInAServer);
CachedMessage cachedMessage = CachedMessage.builder().build();
when(messageCache.getMessageFromCache(originServer.getId(), channel.getId(), messageId)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);

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

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.utility.listener.embed;
import dev.sheldan.abstracto.core.metrics.service.MetricService;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.cache.CachedEmote;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
@@ -26,8 +27,6 @@ import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class MessageEmbedRemovalReactionListenerTest {
public static final long EMBEDDING_USER_ID = 6L;
public static final long EMBEDDED_USER_ID = 7L;
@InjectMocks
private MessageEmbedRemovalReactionListener testUnit;
@@ -40,6 +39,9 @@ public class MessageEmbedRemovalReactionListenerTest {
@Mock
private EmoteService emoteService;
@Mock
private MetricService metricService;
@Mock
private CachedReactions messageReaction;
@@ -92,6 +94,8 @@ public class MessageEmbedRemovalReactionListenerTest {
public void testEmbeddedUserAddingReaction() {
when(embeddedUser.getUserReference()).thenReturn(embeddedAUser);
when(embeddedAUser.getId()).thenReturn(USER_ID + 1);
when(embeddingUser.getUserReference()).thenReturn(embeddingAUser);
when(embeddingAUser.getId()).thenReturn(USER_ID + 3);
when(reactingUser.getUserId()).thenReturn(USER_ID + 1);
executeDeletionTest(embeddingUser, embeddedUser, reactingUser, 1);
}

34
abstracto-application/abstracto-modules/utility/utility-impl/src/test/java/dev/sheldan/abstracto/utility/listener/repost/RepostEmbedListenerTest.java
View File

@@ -2,13 +2,15 @@ package dev.sheldan.abstracto.utility.listener.repost;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.listener.GuildMessageEmbedEventModel;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.utility.service.RepostCheckChannelService;
import dev.sheldan.abstracto.utility.service.RepostService;
import dev.sheldan.abstracto.utility.service.management.PostedImageManagement;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.requests.RestAction;
import net.dv8tion.jda.api.entities.EmbedType;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.TextChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -17,7 +19,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@@ -40,7 +42,7 @@ public class RepostEmbedListenerTest {
private ChannelManagementService channelManagementService;
@Mock
private BotService botService;
private ChannelService channelService;
@Mock
private GuildMessageEmbedEventModel model;
@@ -80,8 +82,7 @@ public class RepostEmbedListenerTest {
public void testExecuteNoEmbeds() {
channelSetup();
setupMessageHasBeenCovered(false);
RestAction messageRestAction = Mockito.mock(RestAction.class);
when(textChannel.retrieveMessageById(MESSAGE_ID)).thenReturn(messageRestAction);
when(channelService.retrieveMessageInChannel(SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(message));
testUnit.execute(model);
verify(repostService, times(0)).processMessageEmbedsRepostCheck(anyList(), any(Message.class));
}
@@ -90,12 +91,10 @@ public class RepostEmbedListenerTest {
public void testExecuteOneImageEmbed() {
channelSetup();
setupMessageHasBeenCovered(false);
RestAction<Message> messageRestAction = Mockito.mock(RestAction.class);
MessageEmbed imageEmbed = Mockito.mock(MessageEmbed.class);
when(imageEmbed.getType()).thenReturn(EmbedType.IMAGE);
when(model.getEmbeds()).thenReturn(Arrays.asList(imageEmbed));
mockMessageConsumer(messageRestAction, message);
when(textChannel.retrieveMessageById(MESSAGE_ID)).thenReturn(messageRestAction);
when(channelService.retrieveMessageInChannel(SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(message));
testUnit.execute(model);
verifySingleEmbedProcessed(imageEmbed);
}
@@ -104,14 +103,12 @@ public class RepostEmbedListenerTest {
public void testExecuteMultipleEmbedsOneImage() {
channelSetup();
setupMessageHasBeenCovered(false);
RestAction<Message> messageRestAction = Mockito.mock(RestAction.class);
MessageEmbed imageEmbed = Mockito.mock(MessageEmbed.class);
MessageEmbed nonImageEmbed = Mockito.mock(MessageEmbed.class);
when(imageEmbed.getType()).thenReturn(EmbedType.IMAGE);
when(nonImageEmbed.getType()).thenReturn(EmbedType.LINK);
when(model.getEmbeds()).thenReturn(Arrays.asList(imageEmbed, nonImageEmbed));
mockMessageConsumer(messageRestAction, message);
when(textChannel.retrieveMessageById(MESSAGE_ID)).thenReturn(messageRestAction);
when(channelService.retrieveMessageInChannel(SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(message));
testUnit.execute(model);
verifySingleEmbedProcessed(imageEmbed);
}
@@ -128,22 +125,11 @@ public class RepostEmbedListenerTest {
Assert.assertEquals(imageEmbed, embeds.get(0));
}
private void mockMessageConsumer(RestAction<Message> action, Message message) {
doAnswer(invocationOnMock -> {
Object consumerObj = invocationOnMock.getArguments()[0];
if(consumerObj instanceof Consumer) {
Consumer<Message> consumer = (Consumer<Message>) consumerObj;
consumer.accept(message);
}
return null;
}).when(action).queue(any(Consumer.class));
}
private void channelSetup() {
when(model.getChannelId()).thenReturn(CHANNEL_ID);
when(model.getServerId()).thenReturn(SERVER_ID);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(channel);
when(botService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenReturn(textChannel);
when(repostCheckChannelService.duplicateCheckEnabledForChannel(channel)).thenReturn(true);
}

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

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.utility.listener.starboard;
import dev.sheldan.abstracto.core.metrics.service.MetricService;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
import dev.sheldan.abstracto.core.models.cache.CachedEmote;
@@ -13,7 +14,6 @@ import dev.sheldan.abstracto.utility.models.database.StarboardPost;
import dev.sheldan.abstracto.utility.service.StarboardService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostManagementService;
import dev.sheldan.abstracto.utility.service.management.StarboardPostReactorManagementService;
import net.dv8tion.jda.api.entities.MessageReaction;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -54,10 +54,10 @@ public class StarboardListenerTest {
private EmoteService emoteService;
@Mock
private CachedReactions cachedReaction;
private MetricService metricService;
@Mock
private MessageReaction.ReactionEmote reactionEmote;
private CachedReactions cachedReaction;
@Mock
private CachedMessage cachedMessage;
@@ -140,6 +140,7 @@ public class StarboardListenerTest {
Long requiredStars = 1L;
setupActingAndAuthor();
executeAddingTest(requiredStars, null);
verify(metricService, times(2)).incrementCounter(any());
verify(starboardService, times(1)).createStarboardPost(any(CachedMessage.class), anyList(), eq(userInServerActing), eq(userInAServer));
}
@@ -148,6 +149,7 @@ public class StarboardListenerTest {
Long requiredStars = 1L;
setupActingAndAuthor();
executeAddingTest(requiredStars, post);
verify(metricService, times(1)).incrementCounter(any());
verify(starboardService, times(1)).updateStarboardPost(eq(post), any(CachedMessage.class), anyList());
verify(starboardPostReactorManagementService, times(1)).addReactor(post, userInServerActing);
}
@@ -185,8 +187,9 @@ public class StarboardListenerTest {
Long requiredStars = 0L;
List<ServerUser> remainingUsers = Arrays.asList(serverUserActing);
setupActingAndAuthor();
when(userInServerManagementService.loadUser(serverUserActing)).thenReturn(userInServerActing);
when(userInServerManagementService.loadOrCreateUser(serverUserActing)).thenReturn(userInServerActing);
executeRemovalTest(requiredStars, remainingUsers);
verify(metricService, times(1)).incrementCounter(any());
verify(starboardService, times(0)).deleteStarboardMessagePost(eq(post));
verify(starboardPostManagementService, times(0)).removePost(eq(post));
}
@@ -197,13 +200,14 @@ public class StarboardListenerTest {
ArrayList<ServerUser> usersRemaining = new ArrayList<>();
setupActingAndAuthor();
executeRemovalTest(requiredStars, usersRemaining);
verify(metricService, times(2)).incrementCounter(any());
verify(starboardService, times(1)).deleteStarboardMessagePost(eq(post));
verify(starboardPostManagementService, times(1)).removePost(eq(post));
}
@Test
public void testReactionsClearedOnStarredMessage() {
executeClearingTest(StarboardPost.builder().build());
executeClearingTest(Mockito.mock(StarboardPost.class));
}
@Test
@@ -244,7 +248,7 @@ public class StarboardListenerTest {
when(reaction.getUsers()).thenReturn(remainingUsers);
when(emoteService.getReactionFromMessageByEmote(cachedMessage, starEmote)).thenReturn(Optional.of(reaction));
when(starboardPostManagementService.findByMessageId(MESSAGE_ID)).thenReturn(Optional.ofNullable(post));
when(userInServerManagementService.loadUser(SERVER_ID, AUTHOR_ID)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, AUTHOR_ID)).thenReturn(userInAServer);
when(serverUserActing.getUserId()).thenReturn(USER_ACTING_ID);
when(serverUserActing.getServerId()).thenReturn(SERVER_ID);
if(!remainingUsers.isEmpty()) {
@@ -270,8 +274,8 @@ public class StarboardListenerTest {
when(reaction.getUsers()).thenReturn(Arrays.asList(serverUserActing));
when(emoteService.getReactionFromMessageByEmote(cachedMessage, starEmote)).thenReturn(Optional.of(reaction));
when(starboardPostManagementService.findByMessageId(MESSAGE_ID)).thenReturn(Optional.ofNullable(postToUse));
when(userInServerManagementService.loadUser(SERVER_ID, AUTHOR_ID)).thenReturn(userInAServer);
when(userInServerManagementService.loadUser(serverUserActing)).thenReturn(userInServerActing);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, AUTHOR_ID)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(serverUserActing)).thenReturn(userInServerActing);
when(userInServerManagementService.loadUserOptional(SERVER_ID, USER_ACTING_ID)).thenReturn(Optional.of(userInServerActing));
AConfig starRequirementConfig = Mockito.mock(AConfig.class);
when(starRequirementConfig.getLongValue()).thenReturn(requiredStars);

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

@@ -2,7 +2,7 @@ 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.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;
@@ -28,7 +28,7 @@ public class StarStatsUserConverterTest {
private StarStatsUserConverter testUnit;
@Mock
private BotService botService;
private MemberService memberService;
@Mock
private UserInServerManagementService userInServerManagementService;
@@ -47,8 +47,8 @@ public class StarStatsUserConverterTest {
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(userInServerManagementService.loadOrCreateUser(firstUserId)).thenReturn(firstUser);
when(memberService.getMemberInServerAsync(serverId, firstUserId)).thenReturn(CompletableFuture.completedFuture(firstMember));
when(firstResult.getUserId()).thenReturn(firstUserId);
when(firstResult.getStarCount()).thenReturn(firstStarCount);
results.add(firstResult);
@@ -58,8 +58,8 @@ public class StarStatsUserConverterTest {
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(userInServerManagementService.loadOrCreateUser(secondUserId)).thenReturn(secondUser);
when(memberService.getMemberInServerAsync(serverId, secondUserId)).thenReturn(CompletableFuture.completedFuture(secondMember));
when(secondResult.getUserId()).thenReturn(secondUserId);
when(secondResult.getStarCount()).thenReturn(secondStarCount);
@@ -83,7 +83,7 @@ public class StarStatsUserConverterTest {
List<StarStatsUserResult> results = new ArrayList<>();
List<CompletableFuture<StarStatsUser>> starStatsUsers = testUnit.convertToStarStatsUser(results, serverId);
verify(botService, times(0)).getMemberInServer(eq(serverId), anyLong());
verify(memberService, times(0)).getMemberInServer(eq(serverId), anyLong());
Assert.assertEquals(0, starStatsUsers.size());
}

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

@@ -4,10 +4,7 @@ import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.models.template.listener.MessageEmbeddedModel;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.MessageCache;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
@@ -46,7 +43,7 @@ public class MessageEmbedServiceBeanTest {
private UserInServerManagementService userInServerManagementService;
@Mock
private BotService botService;
private MemberService memberService;
@Mock
private TemplateService templateService;
@@ -210,7 +207,7 @@ public class MessageEmbedServiceBeanTest {
when(cachedAuthor.getAuthorId()).thenReturn(USER_ID);
when(cachedMessage.getAuthor()).thenReturn(cachedAuthor);
when(userInServerManagementService.loadUserOptional(EMBEDDING_USER_IN_SERVER_ID)).thenReturn(Optional.of(embeddingUser));
when(botService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(embeddingMember));
when(memberService.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));

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

@@ -5,13 +5,14 @@ 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.ChannelService;
import dev.sheldan.abstracto.core.service.GuildService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.scheduling.service.SchedulerService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
import dev.sheldan.abstracto.templating.service.TemplateService;
import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.exception.ReminderNotFoundException;
import dev.sheldan.abstracto.utility.models.database.Reminder;
import dev.sheldan.abstracto.utility.service.management.ReminderManagementService;
@@ -59,7 +60,10 @@ public class RemindServiceBeanTest {
private SchedulerService schedulerService;
@Mock
private BotService botService;
private GuildService guildService;
@Mock
private MemberService memberService;
@Mock
private ReminderService self;
@@ -131,10 +135,10 @@ public class RemindServiceBeanTest {
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.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.of(channel));
when(guildService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(channelService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.of(channel));
Member mockedMember = Mockito.mock(Member.class);
when(botService.getMemberInServerAsync(server.getId(), remindedUser.getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(mockedMember));
when(memberService.getMemberInServerAsync(server.getId(), remindedUser.getUserReference().getId())).thenReturn(CompletableFuture.completedFuture(mockedMember));
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@@ -150,8 +154,8 @@ public class RemindServiceBeanTest {
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.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(botService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.empty());
when(guildService.getGuildByIdOptional(server.getId())).thenReturn(Optional.of(guildMock));
when(channelService.getTextChannelFromServerOptional(server.getId(), aChannel.getId())).thenReturn(Optional.empty());
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@@ -168,7 +172,7 @@ public class RemindServiceBeanTest {
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(remindedReminder);
when(botService.getGuildByIdOptional(server.getId())).thenReturn(Optional.empty());
when(guildService.getGuildByIdOptional(server.getId())).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@@ -179,7 +183,7 @@ public class RemindServiceBeanTest {
Reminder remindedReminder = Reminder.builder().reminded(true).build();
when(reminderManagementService.loadReminder(reminderId)).thenReturn(remindedReminder);
testUnit.executeReminder(reminderId);
verify(botService, times(0)).getGuildByIdOptional(anyLong());
verify(guildService, times(0)).getGuildByIdOptional(anyLong());
}
@Test

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

@@ -6,10 +6,7 @@ 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.FeatureModeService;
import dev.sheldan.abstracto.core.service.HashService;
import dev.sheldan.abstracto.core.service.HttpService;
import dev.sheldan.abstracto.core.service.MessageService;
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;
@@ -24,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.*;
import net.dv8tion.jda.api.entities.Guild;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -72,7 +69,7 @@ public class RepostServiceBeanTest {
private UserInServerManagementService userInServerManagementService;
@Mock
private MessageService messageService;
private ReactionService reactionService;
@Mock
private FeatureModeService featureModeService;
@@ -159,7 +156,7 @@ public class RepostServiceBeanTest {
public void testPersistRepostWithExisting() {
Integer count = 4;
when(postedImageManagement.getPostFromMessageAndPosition(MESSAGE_ID, POSITION)).thenReturn(postedImage);
when(userInServerManagementService.loadUser(SERVER_ID, USER_ID)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(userInAServer);
when(repost.getCount()).thenReturn(count);
when(repostManagementService.findRepostOptional(postedImage, userInAServer)).thenReturn(Optional.of(repost));
testUnit.persistRepost(MESSAGE_ID, POSITION, SERVER_ID, USER_ID);
@@ -169,7 +166,7 @@ public class RepostServiceBeanTest {
@Test
public void testPersistRepostWithoutExisting() {
when(postedImageManagement.getPostFromMessageAndPosition(MESSAGE_ID, POSITION)).thenReturn(postedImage);
when(userInServerManagementService.loadUser(SERVER_ID, USER_ID)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(userInAServer);
when(repostManagementService.findRepostOptional(postedImage, userInAServer)).thenReturn(Optional.empty());
testUnit.persistRepost(MESSAGE_ID, POSITION, SERVER_ID, USER_ID);
verify(repostManagementService, times(1)).createRepost(postedImage, userInAServer);
@@ -224,7 +221,7 @@ public class RepostServiceBeanTest {
setupSingleRepost();
testUnit.processMessageAttachmentRepostCheck(message);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(0));
verify(messageService, times(0)).addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
verify(reactionService, times(0)).addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@Test
@@ -237,9 +234,9 @@ public class RepostServiceBeanTest {
setupSingleHash(postedImage);
Long originalPostMessageId = MESSAGE_ID + 1;
when(postedImage.getPostId()).thenReturn(new PostIdentifier(originalPostMessageId, POSITION));
when(messageService.addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.processMessageAttachmentRepostCheck(message);
verify(messageService, times(0)).addDefaultReactionToMessageAsync(anyString(), eq(SERVER_ID), eq(CHANNEL_ID), eq(MESSAGE_ID));
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);
}
@@ -261,8 +258,8 @@ public class RepostServiceBeanTest {
when(postedImageManagement.getPostWithHash(secondAttachmentHash, server)).thenReturn(Optional.of(postedImage));
Long originalPostMessageId = MESSAGE_ID + 1;
when(postedImage.getPostId()).thenReturn(new PostIdentifier(originalPostMessageId, POSITION));
when(messageService.addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(messageService.addDefaultReactionToMessageAsync(anyString(), eq(SERVER_ID), eq(CHANNEL_ID), eq(MESSAGE_ID))).thenReturn(CompletableFuture.completedFuture(null));
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);
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);
@@ -277,7 +274,7 @@ public class RepostServiceBeanTest {
}
private void generalSetupForRepostTest() {
when(userInServerManagementService.loadUser(SERVER_ID, USER_ID)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(userInAServer);
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
}
@@ -309,7 +306,7 @@ public class RepostServiceBeanTest {
setupSingleRepost();
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, message);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(EMBEDDED_LINK_POSITION_START_INDEX));
verify(messageService, times(0)).addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
verify(reactionService, times(0)).addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@Test
@@ -328,7 +325,7 @@ public class RepostServiceBeanTest {
setupSingleRepost();
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, message);
verify(postedImageManagement, times(1)).createPost(any(AServerAChannelAUser.class), eq(MESSAGE_ID), eq(HASH), eq(EMBEDDED_LINK_POSITION_START_INDEX));
verify(messageService, times(0)).addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
verify(reactionService, times(0)).addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID);
}
@Test
@@ -344,7 +341,7 @@ public class RepostServiceBeanTest {
setupSingleHash(postedImage);
Long originalPostMessageId = MESSAGE_ID + 1;
when(postedImage.getPostId()).thenReturn(new PostIdentifier(originalPostMessageId, POSITION));
when(messageService.addReactionToMessageWithFuture(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(reactionService.addReactionToMessageAsync(REPOST_MARKER_EMOTE_KEY, SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.processMessageEmbedsRepostCheck(messageEmbeds, message);
verify(self, times(1)).persistRepost(originalPostMessageId, POSITION, SERVER_ID, USER_ID);
}

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

@@ -5,10 +5,7 @@ import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.database.*;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.PostTargetService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.core.service.management.PostTargetManagement;
@@ -50,7 +47,13 @@ public class StarboardServiceBeanTest {
private StarboardServiceBean testUnit;
@Mock
private BotService botService;
private GuildService guildService;
@Mock
private ChannelService channelService;
@Mock
private MemberService memberService;
@Mock
private PostTargetService postTargetService;
@@ -79,6 +82,9 @@ public class StarboardServiceBeanTest {
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private MessageService messageService;
@Mock
private EmoteService emoteService;
@@ -137,9 +143,9 @@ public class StarboardServiceBeanTest {
when(message.getServerId()).thenReturn(SERVER_ID);
when(message.getChannelId()).thenReturn(CHANNEL_ID);
Member authorMember = Mockito.mock(Member.class);
when(botService.getMemberInServerAsync(SERVER_ID, STARRED_USER_ID)).thenReturn(CompletableFuture.completedFuture(authorMember));
when(botService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.of(mockedTextChannel));
when(botService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(guild));
when(memberService.getMemberInServerAsync(SERVER_ID, STARRED_USER_ID)).thenReturn(CompletableFuture.completedFuture(authorMember));
when(channelService.getTextChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.of(mockedTextChannel));
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(guild));
ADefaultConfig config = Mockito.mock(ADefaultConfig.class);
when(config.getLongValue()).thenReturn(3L);
when(defaultConfigManagementService.getDefaultConfig(StarboardServiceBean.STAR_LEVELS_CONFIG_KEY)).thenReturn(config);
@@ -217,7 +223,7 @@ public class StarboardServiceBeanTest {
when(config.getLongValue()).thenReturn(4L);
when(defaultConfigManagementService.getDefaultConfig(StarboardServiceBean.STAR_LEVELS_CONFIG_KEY)).thenReturn(config);
when(starboardPostManagementService.findByStarboardPostId(starboardPostId)).thenReturn(Optional.of(post));
when(botService.getMemberInServerAsync(SERVER_ID, STARRED_USER_ID)).thenReturn(CompletableFuture.completedFuture(starredMember));
when(memberService.getMemberInServerAsync(SERVER_ID, STARRED_USER_ID)).thenReturn(CompletableFuture.completedFuture(starredMember));
List<AUserInAServer > userExceptAuthor = new ArrayList<>();
testUnit.updateStarboardPost(post, message, userExceptAuthor);
verify(postTargetService, times(1)).editOrCreatedInPostTarget(oldPostId, postMessage, StarboardPostTarget.STARBOARD, SERVER_ID);
@@ -236,7 +242,7 @@ public class StarboardServiceBeanTest {
when(post.getSourceChanel()).thenReturn(channel);
when(post.getStarboardChannel()).thenReturn(channel);
testUnit.deleteStarboardMessagePost(post);
verify(botService, times(1)).deleteMessage(SERVER_ID, CHANNEL_ID, messageId);
verify(messageService, times(1)).deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, messageId);
}
@Test(expected = UserInServerNotFoundException.class)

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

@@ -6,10 +6,7 @@ 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;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.PostTargetService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.templating.model.MessageToSend;
@@ -22,7 +19,6 @@ import dev.sheldan.abstracto.utility.models.database.Suggestion;
import dev.sheldan.abstracto.utility.models.template.commands.SuggestionLog;
import dev.sheldan.abstracto.utility.service.management.SuggestionManagementService;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.requests.RestAction;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -56,10 +52,13 @@ public class SuggestionServiceBeanTest {
private TemplateService templateService;
@Mock
private BotService botService;
private ChannelService channelService;
@Mock
private MessageService messageService;
private MemberService memberService;
@Mock
private ReactionService reactionService;
@Mock
private SuggestionServiceBean self;
@@ -115,12 +114,12 @@ public class SuggestionServiceBeanTest {
Message suggestionMessage = Mockito.mock(Message.class);
when(counterService.getNextCounterValue(server, SUGGESTION_COUNTER_KEY)).thenReturn(SUGGESTION_ID);
AUserInAServer aUserInAServer = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUser(suggestionCreator)).thenReturn(aUserInAServer);
when(userInServerManagementService.loadOrCreateUser(suggestionCreator)).thenReturn(aUserInAServer);
List<CompletableFuture<Message>> postingFutures = Arrays.asList(CompletableFuture.completedFuture(suggestionMessage));
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_ID, suggestionMessage);
verify( messageService, times(1)).addReactionToMessageWithFuture(SuggestionServiceBean.SUGGESTION_NO_EMOTE, SERVER_ID, suggestionMessage);
verify(reactionService, times(1)).addReactionToMessageAsync(SuggestionServiceBean.SUGGESTION_YES_EMOTE, SERVER_ID, suggestionMessage);
verify(reactionService, times(1)).addReactionToMessageAsync(SuggestionServiceBean.SUGGESTION_NO_EMOTE, SERVER_ID, suggestionMessage);
}
@Test
@@ -167,7 +166,7 @@ public class SuggestionServiceBeanTest {
.build();
when(server.getId()).thenReturn(SERVER_ID);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(botService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenThrow(new ChannelNotInGuildException(CHANNEL_ID));
when(channelService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenThrow(new ChannelNotInGuildException(CHANNEL_ID));
when(suggestionManagementService.getSuggestion(SUGGESTION_ID)).thenReturn(Optional.of(suggestionToAccept));
}
@@ -220,11 +219,9 @@ public class SuggestionServiceBeanTest {
Long messageId = 7L;
SuggestionLog logParameter = SuggestionLog.builder().build();
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));
when(botService.getMemberInServerAsync(SERVER_ID, SUGGESTER_ID)).thenReturn(CompletableFuture.completedFuture(actualMember));
when(channelService.retrieveMessageInChannel(textChannel, messageId)).thenReturn(CompletableFuture.completedFuture(suggestionMessage));
when(memberService.getMemberInServerAsync(SERVER_ID, SUGGESTER_ID)).thenReturn(CompletableFuture.completedFuture(actualMember));
testUnit.acceptSuggestion(SUGGESTION_ID, CLOSING_TEXT, logParameter);
verify(suggestionManagementService, times(1)).setSuggestionState(suggestionToAccept, SuggestionState.ACCEPTED);
}
@@ -233,11 +230,9 @@ public class SuggestionServiceBeanTest {
Long messageId = 7L;
SuggestionLog logParameter = SuggestionLog.builder().build();
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));
when(botService.getMemberInServerAsync(SERVER_ID, SUGGESTER_ID)).thenReturn(CompletableFuture.completedFuture(actualMember));
when(channelService.retrieveMessageInChannel(textChannel, messageId)).thenReturn(CompletableFuture.completedFuture(suggestionMessage));
when(memberService.getMemberInServerAsync(SERVER_ID, SUGGESTER_ID)).thenReturn(CompletableFuture.completedFuture(actualMember));
testUnit.rejectSuggestion(SUGGESTION_ID, CLOSING_TEXT, logParameter);
verify(suggestionManagementService, times(1)).setSuggestionState(suggestionToAccept, SuggestionState.REJECTED);
}
@@ -256,7 +251,7 @@ public class SuggestionServiceBeanTest {
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);
when(channelService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenReturn(textChannel);
return suggestionToAccept;
}
}

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

@@ -12,7 +12,10 @@ import dev.sheldan.abstracto.core.test.MockUtils;
import dev.sheldan.abstracto.utility.exception.CrossServerEmbedException;
import dev.sheldan.abstracto.utility.models.database.EmbeddedMessage;
import dev.sheldan.abstracto.utility.repository.EmbeddedMessageRepository;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageChannel;
import net.dv8tion.jda.api.entities.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -79,7 +82,7 @@ public class MessageEmbedPostManagementServiceBeanTest {
when(embeddingMessage.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(embeddingMessage.getIdLong()).thenReturn(EMBEDDING_MESSAGE_ID);
when(userInServerManagementService.loadUser(SERVER_ID, EMBEDDED_USER_ID)).thenReturn(embeddedUser);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, EMBEDDED_USER_ID)).thenReturn(embeddedUser);
testUnit.createMessageEmbed(cachedMessage, embeddingMessage, embeddingUser);
verify(embeddedMessageRepository, times(1)).save(messageArgumentCaptor.capture());
EmbeddedMessage savedMessage = messageArgumentCaptor.getValue();

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

@@ -78,7 +78,7 @@ public class SuggestionManagementServiceBeanTest {
when(message.getChannel()).thenReturn(messageChannel);
when(message.getGuild()).thenReturn(guild);
when(guild.getId()).thenReturn("5");
when(userInServerManagementService.loadUser(member)).thenReturn(userInAServer);
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(userInAServer);
long suggestionId = 1L;
Suggestion createdSuggestion = testUnit.createSuggestion(member, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);