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

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

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

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

@@ -149,7 +149,7 @@ public class RemindServiceBean implements ReminderService {
@Override
public void unRemind(Long reminderId, AUserInAServer aUserInAServer) {
log.info("Trying to end reminder {} for user {} in server {}.", reminderId, aUserInAServer.getUserReference().getId(),aUserInAServer.getServerReference().getId());
log.info("Trying to end reminder {} for user {} in server {}.", reminderId, aUserInAServer.getUserReference().getId(), aUserInAServer.getServerReference().getId());
Reminder reminder = reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, reminderId).orElseThrow(() -> new ReminderNotFoundException(reminderId));
reminder.setReminded(true);
if(reminder.getJobTriggerKey() != null) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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