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

[AB-215] adding create alias and delete alias commands to create service specific aliases for commands

Browse Source 
renaming package in commands package
defaulting to latest in docker compose build for deployment container
fixing jacoco configuration
changing that if there are no parameters required, parameters are accepted
This commit is contained in:
Sheldan
2021-03-27 13:17:27 +01:00
parent a494d4d2f2
commit 9541f907b8
135 changed files with 1904 additions and 376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RollTest.java
View File

@@ -49,7 +49,7 @@ public class RollTest {
Long serverId = 3L;
Integer max = 10;
when(noParameters.getGuild().getIdLong()).thenReturn(serverId);
when(configService.getLongValue(ROLL_DEFAULT_HIGH_KEY, serverId)).thenReturn(max.longValue());
when(configService.getLongValueOrConfigDefault(ROLL_DEFAULT_HIGH_KEY, serverId)).thenReturn(max.longValue());
when(entertainmentService.calculateRollResult(1, max)).thenReturn(result);
when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);

2
abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/service/EntertainmentServiceBeanTest.java
View File

@@ -79,7 +79,7 @@ public class EntertainmentServiceBeanTest {
when(guild.getIdLong()).thenReturn(serverId);
when(member.getGuild()).thenReturn(guild);
Long sides = 6L;
when(configService.getLongValue(EntertainmentFeatureConfig.ROULETTE_BULLETS_CONFIG_KEY, serverId)).thenReturn(sides);
when(configService.getLongValueOrConfigDefault(EntertainmentFeatureConfig.ROULETTE_BULLETS_CONFIG_KEY, serverId)).thenReturn(sides);
when(secureRandom.nextInt(sides.intValue())).thenReturn(randomValue);
boolean shot = testUnit.executeRoulette(member);
Assert.assertEquals(randomValue == 0, shot);

3
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListener.java
View File

@@ -37,11 +37,10 @@ public class JoiningUserRoleListener implements AsyncJoinListener {
public DefaultListenerResult execute(MemberJoinModel model) {
AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(model.getServerId(), model.getJoiningUser().getUserId());
AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
Long userInServerId = userInAServer.getUserInServerId();
if(userExperience != null) {
log.info("User {} joined {} with previous experience. Setting up experience role again (if necessary).", model.getJoiningUser().getUserId(), model.getServerId());
userExperienceService.syncForSingleUser(userExperience).thenAccept(result ->
log.info("Finished re-assigning experience for re-joining user {} in server {}.", userInServerId, model.getServerId())
log.info("Finished re-assigning experience for re-joining user {} in server {}.", model.getJoiningUser().getUserId(), model.getServerId())
);
} else {
log.info("Joined user {} in server {} does not have any previous experience. Not setting up anything.", model.getJoiningUser().getUserId(), model.getServerId());

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

@@ -1,5 +1,7 @@
package dev.sheldan.abstracto.experience.listener;
import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
import dev.sheldan.abstracto.core.listener.ListenerExecutionResult;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
@@ -7,6 +9,7 @@ import dev.sheldan.abstracto.core.service.management.UserInServerManagementServi
import dev.sheldan.abstracto.experience.model.database.AUserExperience;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -48,9 +51,9 @@ public class JoiningUserRoleListenerTest {
@Before
public void setup() {
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(serverUser.getUserId()).thenReturn(USER_ID);
when(model.getJoiningUser()).thenReturn(serverUser);
when(model.getServerId()).thenReturn(SERVER_ID);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(aUserInAServer);
}
@@ -59,7 +62,8 @@ public class JoiningUserRoleListenerTest {
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
when(userExperienceService.syncForSingleUser(experience)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.execute(model);
DefaultListenerResult result = testUnit.execute(model);
Assert.assertEquals(DefaultListenerResult.PROCESSED, result);
}
@Test

3
abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/test/java/dev/sheldan/abstracto/linkembed/service/management/MessageEmbedPostManagementServiceBeanTest.java
View File

@@ -59,7 +59,6 @@ public class MessageEmbedPostManagementServiceBeanTest {
AUserInAServer embeddedUser = Mockito.mock(AUserInAServer.class);
AChannel channel = Mockito.mock(AChannel.class);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
when(channelManagementService.loadChannel(EMBEDDING_CHANNEL_ID)).thenReturn(channel);
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
@@ -69,7 +68,6 @@ public class MessageEmbedPostManagementServiceBeanTest {
CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
when(cachedAuthor.getAuthorId()).thenReturn(EMBEDDED_USER_ID);
when(cachedMessage.getAuthor()).thenReturn(cachedAuthor);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
Message embeddingMessage = Mockito.mock(Message.class);
MessageChannel embeddingChannel = Mockito.mock(MessageChannel.class);
when(embeddingChannel.getIdLong()).thenReturn(EMBEDDING_CHANNEL_ID);
@@ -99,7 +97,6 @@ public class MessageEmbedPostManagementServiceBeanTest {
public void testToCreateEmbedForDifferentServers() {
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);

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/LeaveLogger.java
View File

@@ -51,7 +51,7 @@ public class LeaveLogger implements AsyncLeaveListener {
@Override
public DefaultListenerResult execute(MemberLeaveModel model) {
String text = templateService.renderTemplateWithMap(USER_LEAVE_TEMPLATE, getUserParameter(model.getMember().getUser()), model.getLeavingUser().getServerId());
String text = templateService.renderTemplateWithMap(USER_LEAVE_TEMPLATE, getUserParameter(model.getMember().getUser()), model.getServerId());
postTargetService.sendTextInPostTarget(text, LoggingPostTarget.LEAVE_LOG, model.getServerId());
return DefaultListenerResult.PROCESSED;
}

6
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListener.java
View File

@@ -45,7 +45,7 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
log.trace("Message content was the same. Possible reason was: message was not in cache.");
return DefaultListenerResult.IGNORED;
}
log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), messageBefore.getServerId());
log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), model.getServerId());
TextChannel textChannel = channelService.getTextChannelFromServer(model.getServerId(), messageBefore.getChannelId());
MessageEditedLog log = MessageEditedLog
.builder()
@@ -55,8 +55,8 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
.guild(textChannel.getGuild())
.member(messageAfter.getMember())
.build();
MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log, messageBefore.getServerId());
postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, messageBefore.getServerId());
MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log, model.getServerId());
postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, model.getServerId());
return DefaultListenerResult.PROCESSED;
}

7
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinLoggerTest.java
View File

@@ -49,14 +49,11 @@ public class JoinLoggerTest {
@Test
public void testExecute() {
when(serverUser.getUserId()).thenReturn(USER_ID);
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(model.getMember()).thenReturn(member);
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
testUnit.execute(model);
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(model.getServerId()).thenReturn(SERVER_ID);
String message = "text";
when(templateService.renderTemplateWithMap(eq(JoinLogger.USER_JOIN_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
testUnit.execute(model);
verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.JOIN_LOG, SERVER_ID);
}

14
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinMuteListenerTest.java
View File

@@ -31,12 +31,6 @@ public class JoinMuteListenerTest {
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private Member member;
@Mock
private Guild guild;
@Mock
private AUserInAServer joiningUser;
@@ -51,22 +45,22 @@ public class JoinMuteListenerTest {
@Test
public void testNonMutedUserJoins() {
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(serverUser.getUserId()).thenReturn(USER_ID);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(joiningUser);
when(muteManagementService.hasActiveMute(joiningUser)).thenReturn(false);
when(model.getMember()).thenReturn(member);
when(model.getServerId()).thenReturn(SERVER_ID);
when(model.getJoiningUser()).thenReturn(serverUser);
testUnit.execute(model);
verify(muteService, times(0)).applyMuteRole(joiningUser);
}
@Test
public void testMutedUserJoins() {
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(model.getServerId()).thenReturn(SERVER_ID);
when(serverUser.getUserId()).thenReturn(USER_ID);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(joiningUser);
when(muteManagementService.hasActiveMute(joiningUser)).thenReturn(true);
when(model.getMember()).thenReturn(member);
when(model.getJoiningUser()).thenReturn(serverUser);
testUnit.execute(model);
verify(muteService, times(1)).applyMuteRole(joiningUser);
}

5
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/LeaveLoggerTest.java
View File

@@ -51,14 +51,11 @@ public class LeaveLoggerTest {
@Test
public void testExecute() {
when(leavingUser.getUserId()).thenReturn(USER_ID);
when(leavingUser.getServerId()).thenReturn(SERVER_ID);
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
when(model.getServerId()).thenReturn(SERVER_ID);
when(model.getMember()).thenReturn(member);
User user = Mockito.mock(User.class);
when(member.getUser()).thenReturn(user);
String message = "text";
when(leavingUser.getServerId()).thenReturn(SERVER_ID);
when(templateService.renderTemplateWithMap(eq(LeaveLogger.USER_LEAVE_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
testUnit.execute(model);
verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.LEAVE_LOG, SERVER_ID);

1
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListenerTest.java
View File

@@ -94,7 +94,6 @@ public class MessageDeleteLogListenerTest {
public void testExecuteListener() {
when(deletedMessage.getAuthor()).thenReturn(cachedAuthor);
when(cachedAuthor.getAuthorId()).thenReturn(AUTHOR_ID);
when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
when(memberService.getMemberInServerAsync(SERVER_ID, AUTHOR_ID)).thenReturn(CompletableFuture.completedFuture(member));
when(model.getCachedMessage()).thenReturn(deletedMessage);
when(model.getServerId()).thenReturn(SERVER_ID);

8
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListenerTest.java
View File

@@ -51,6 +51,7 @@ public class MessageEditedListenerTest {
@Mock
private CachedMessage messageBefore;
@Mock
private MessageTextUpdatedModel model;
private static final Long SERVER_ID = 4L;
@@ -77,17 +78,16 @@ public class MessageEditedListenerTest {
Guild guild = Mockito.mock(Guild.class);
when(channel.getGuild()).thenReturn(guild);
Member author = Mockito.mock(Member.class);
CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
when(cachedAuthor.getAuthorId()).thenReturn(AUTHOR_ID);
when(messageBefore.getContent()).thenReturn(content);
when(messageBefore.getServerId()).thenReturn(SERVER_ID);
when(messageBefore.getChannelId()).thenReturn(CHANNEL_ID);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
ArgumentCaptor<MessageEditedLog> captor = ArgumentCaptor.forClass(MessageEditedLog.class);
when(templateService.renderEmbedTemplate(eq(MessageEditedListener.MESSAGE_EDITED_TEMPLATE), captor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
when(memberService.getMemberInServerAsync(SERVER_ID, AUTHOR_ID)).thenReturn(CompletableFuture.completedFuture(author));
when(channelService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenReturn(channel);
when(model.getAfter()).thenReturn(messageAfter);
when(model.getBefore()).thenReturn(messageBefore);
when(messageAfter.getMember()).thenReturn(author);
when(model.getServerId()).thenReturn(SERVER_ID);
testUnit.execute(model);
verify(postTargetService, times(1)).sendEmbedInPostTarget(messageToSend, LoggingPostTarget.EDIT_LOG, SERVER_ID);
MessageEditedLog capturedValue = captor.getValue();

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

@@ -7,6 +7,7 @@ import dev.sheldan.abstracto.moderation.repository.MuteRoleRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -46,8 +47,12 @@ public class MuteRoleManagementServiceBeanTest {
@Test
public void testCreateMuteRoleForServer() {
ARole role = Mockito.mock(ARole.class);
ArgumentCaptor<MuteRole> muteRoleCaptor = ArgumentCaptor.forClass(MuteRole.class);
MuteRole savedRole = Mockito.mock(MuteRole.class);
when(muteRoleRepository.save(muteRoleCaptor.capture())).thenReturn(savedRole);
MuteRole muteRoleForServer = testUnit.createMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRoleForServer, 1);
Assert.assertEquals(savedRole, muteRoleForServer);
Assert.assertEquals(role, muteRoleCaptor.getValue().getRole());
}
@Test
@@ -67,8 +72,12 @@ public class MuteRoleManagementServiceBeanTest {
public void testSetMuteRoleWithoutPrevious() {
ARole role = Mockito.mock(ARole.class);
when(muteRoleRepository.existsByRoleServer(server)).thenReturn(false);
ArgumentCaptor<MuteRole> muteRoleCaptor = ArgumentCaptor.forClass(MuteRole.class);
MuteRole savedRole = Mockito.mock(MuteRole.class);
when(muteRoleRepository.save(muteRoleCaptor.capture())).thenReturn(savedRole);
MuteRole muteRole = testUnit.setMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRole, 1);
Assert.assertEquals(savedRole, muteRole);
Assert.assertEquals(role, muteRoleCaptor.getValue().getRole());
}
@Test
@@ -76,16 +85,11 @@ public class MuteRoleManagementServiceBeanTest {
ARole role = Mockito.mock(ARole.class);
when(muteRoleRepository.existsByRoleServer(server)).thenReturn(true);
MuteRole existingRole = Mockito.mock(MuteRole.class);
when(existingRole.getRole()).thenReturn(role);
when(muteRoleRepository.findByRoleServer(server)).thenReturn(existingRole);
MuteRole muteRole = testUnit.setMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRole, 0);
testUnit.setMuteRoleForServer(server, role);
verify(existingRole, times(1)).setRole(role);
}
private void verifyRoleSaved(ARole role, MuteRole muteRoleForServer, Integer saveCount) {
Assert.assertEquals(role, muteRoleForServer.getRole());
verify(muteRoleRepository, times(saveCount)).save(muteRoleForServer);
}
}

11
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBeanTest.java
View File

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.moderation.repository.UserNoteRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -46,10 +47,14 @@ public class UserNoteManagementServiceBeanTest {
AUser user = Mockito.mock(AUser.class);
when(userInAServer.getUserReference()).thenReturn(user);
when(userInAServer.getServerReference()).thenReturn(server);
UserNote savedNote = Mockito.mock(UserNote.class);
ArgumentCaptor<UserNote> noteCaptor = ArgumentCaptor.forClass(UserNote.class);
when(userNoteRepository.save(noteCaptor.capture())).thenReturn(savedNote);
UserNote userNote = testUnit.createUserNote(userInAServer, NOTE_TEXT);
verify(userNoteRepository, times(1)).save(userNote);
Assert.assertEquals(userInAServer, userNote.getUser());
Assert.assertEquals(NOTE_TEXT, userNote.getNote());
Assert.assertEquals(savedNote, userNote);
UserNote capturedNote = noteCaptor.getValue();
Assert.assertEquals(userInAServer, capturedNote.getUser());
Assert.assertEquals(NOTE_TEXT, capturedNote.getNote());
}
@Test

15
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/WarnManagementServiceBeanTest.java
View File

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.moderation.repository.WarnRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -47,12 +48,16 @@ public class WarnManagementServiceBeanTest {
when(warningUser.getUserReference()).thenReturn(user);
when(warnedUser.getUserReference()).thenReturn(user);
String reason = "REASON";
ArgumentCaptor<Warning> warningArgumentCaptor = ArgumentCaptor.forClass(Warning.class);
Warning savedWarning = Mockito.mock(Warning.class);
when(warnRepository.save(warningArgumentCaptor.capture())).thenReturn(savedWarning);
Warning warning = testUnit.createWarning(warnedUser, warningUser, reason, 8L);
Assert.assertEquals(warningUser, warning.getWarningUser());
Assert.assertEquals(warnedUser, warning.getWarnedUser());
Assert.assertEquals(reason, warning.getReason());
Assert.assertFalse(warning.getDecayed());
verify(warnRepository, times(1)).save(warning);
Assert.assertEquals(savedWarning, warning);
Warning capturedWarning = warningArgumentCaptor.getValue();
Assert.assertEquals(warningUser, capturedWarning.getWarningUser());
Assert.assertEquals(warnedUser, capturedWarning.getWarnedUser());
Assert.assertEquals(reason, capturedWarning.getReason());
Assert.assertFalse(capturedWarning.getDecayed());
}
@Test

4
abstracto-application/abstracto-modules/modmail/modmail-impl/src/test/java/dev/sheldan/abstracto/modmail/listener/ModMailMessageDeletedListenerTest.java
View File

@@ -83,7 +83,6 @@ public class ModMailMessageDeletedListenerTest {
@Test
public void testDeleteNonDuplicatedMessage() {
when(deletedMessage.getMessageId()).thenReturn(DELETED_MESSAGE_ID);
when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
when(modMailMessageManagementService.getByMessageIdOptional(DELETED_MESSAGE_ID)).thenReturn(Optional.of(modMailMessage));
ModMailThread thread = Mockito.mock(ModMailThread.class);
AUserInAServer targetUsInAServer = Mockito.mock(AUserInAServer.class);
@@ -100,6 +99,7 @@ public class ModMailMessageDeletedListenerTest {
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(targetMember));
when(messageService.deleteMessageInChannelWithUser(targetUser, CREATED_MESSAGE_ID_2)).thenReturn(CompletableFuture.completedFuture(null));
when(model.getCachedMessage()).thenReturn(deletedMessage);
when(model.getServerId()).thenReturn(SERVER_ID);
testUnit.execute(model);
verify(messageService, times(0)).deleteMessageInChannelInServer(eq(SERVER_ID), anyLong(), any());
verify(self, times(1)).removeMessageFromThread(DELETED_MESSAGE_ID);
@@ -108,7 +108,6 @@ public class ModMailMessageDeletedListenerTest {
@Test
public void testDeleteDuplicatedMessage() {
when(deletedMessage.getMessageId()).thenReturn(DELETED_MESSAGE_ID);
when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
when(modMailMessageManagementService.getByMessageIdOptional(DELETED_MESSAGE_ID)).thenReturn(Optional.of(modMailMessage));
ModMailThread thread = Mockito.mock(ModMailThread.class);
AUserInAServer targetUsInAServer = Mockito.mock(AUserInAServer.class);
@@ -127,6 +126,7 @@ public class ModMailMessageDeletedListenerTest {
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(targetMember));
when(messageService.deleteMessageInChannelWithUser(targetUser, CREATED_MESSAGE_ID_2)).thenReturn(CompletableFuture.completedFuture(null));
when(messageService.deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, CREATED_MESSAGE_ID_1)).thenReturn(CompletableFuture.completedFuture(null));
when(model.getServerId()).thenReturn(SERVER_ID);
when(model.getCachedMessage()).thenReturn(deletedMessage);
testUnit.execute(model);
verify(self, times(1)).removeMessageFromThread(DELETED_MESSAGE_ID);

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

@@ -10,6 +10,7 @@ import dev.sheldan.abstracto.remind.repository.ReminderRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -56,15 +57,19 @@ public class ReminderManagementServiceBeanTest {
String reminderText = "text";
Instant reminderTargetDate = Instant.ofEpochSecond(1590615937);
Long messageId = 5L;
ArgumentCaptor<Reminder> reminderArgumentCaptor = ArgumentCaptor.forClass(Reminder.class);
Reminder savedReminder = Mockito.mock(Reminder.class);
when(reminderRepository.save(reminderArgumentCaptor.capture())).thenReturn(savedReminder);
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);
Assert.assertEquals(savedReminder, createdReminder);
Reminder capturedReminder = reminderArgumentCaptor.getValue();
Assert.assertEquals(messageId, capturedReminder.getMessageId());
Assert.assertEquals(aUserInAServer, capturedReminder.getRemindedUser());
Assert.assertEquals(server, capturedReminder.getServer());
Assert.assertEquals(reminderText, capturedReminder.getText());
Assert.assertEquals(reminderTargetDate, capturedReminder.getTargetDate());
Assert.assertEquals(channel, capturedReminder.getChannel());
Assert.assertFalse(capturedReminder.isReminded());
}
@Test

13
abstracto-application/abstracto-modules/repost-detection/repost-detection-impl/src/test/java/dev/sheldan/abstracto/repostdetection/service/management/PostedImageManagementBeanTest.java
View File

@@ -12,6 +12,7 @@ import dev.sheldan.abstracto.repostdetection.service.RepostServiceBean;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -55,11 +56,15 @@ public class PostedImageManagementBeanTest {
when(serverAChannelAUser.getGuild()).thenReturn(server);
when(serverAChannelAUser.getChannel()).thenReturn(channel);
when(serverAChannelAUser.getAUserInAServer()).thenReturn(aUserInAServer);
ArgumentCaptor<PostedImage> postedImageArgumentCaptor = ArgumentCaptor.forClass(PostedImage.class);
PostedImage savedPost = Mockito.mock(PostedImage.class);
when(postedImageRepository.save(postedImageArgumentCaptor.capture())).thenReturn(savedPost);
PostedImage createdPost = testUnit.createPost(serverAChannelAUser, MESSAGE_ID, HASH, INDEX);
Assert.assertEquals(HASH, createdPost.getImageHash());
Assert.assertEquals(INDEX, createdPost.getPostId().getPosition());
Assert.assertEquals(MESSAGE_ID, createdPost.getPostId().getMessageId());
verify(postedImageRepository, times(1)).save(createdPost);
Assert.assertEquals(savedPost, createdPost);
PostedImage capturedPost = postedImageArgumentCaptor.getValue();
Assert.assertEquals(HASH, capturedPost.getImageHash());
Assert.assertEquals(INDEX, capturedPost.getPostId().getPosition());
Assert.assertEquals(MESSAGE_ID, capturedPost.getPostId().getMessageId());
}
@Test

17
abstracto-application/abstracto-modules/repost-detection/repost-detection-impl/src/test/java/dev/sheldan/abstracto/repostdetection/service/management/RepostCheckChannelGroupManagementBeanTest.java
View File

@@ -7,10 +7,7 @@ import dev.sheldan.abstracto.repostdetection.repository.RepostCheckChannelReposi
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
@@ -105,12 +102,14 @@ public class RepostCheckChannelGroupManagementBeanTest {
@Test
public void testCreateRepostCheckChannelGroup() {
when(aChannelGroup.getId()).thenReturn(CHANNEL_GROUP_ID);
RepostCheckChannelGroup savedGroup = Mockito.mock(RepostCheckChannelGroup.class);
when(repository.save(checkChannelGroupArgumentCaptor.capture())).thenReturn(savedGroup);
RepostCheckChannelGroup createdCheckChannelGroup = testUnit.createRepostCheckChannelGroup(aChannelGroup);
verify(repository, times(1)).save(checkChannelGroupArgumentCaptor.capture());
Assert.assertEquals(checkChannelGroupArgumentCaptor.getValue(), createdCheckChannelGroup);
Assert.assertTrue(createdCheckChannelGroup.getCheckEnabled());
Assert.assertEquals(CHANNEL_GROUP_ID, createdCheckChannelGroup.getId());
Assert.assertEquals(aChannelGroup, createdCheckChannelGroup.getChannelGroup());
Assert.assertEquals(savedGroup, createdCheckChannelGroup);
RepostCheckChannelGroup capturedGroup = checkChannelGroupArgumentCaptor.getValue();
Assert.assertTrue(capturedGroup.getCheckEnabled());
Assert.assertEquals(CHANNEL_GROUP_ID, capturedGroup.getId());
Assert.assertEquals(aChannelGroup, capturedGroup.getChannelGroup());
}
@Test(expected = RepostCheckChannelGroupNotFoundException.class)

3
abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/listener/StarAddedListenerTest.java
View File

@@ -25,6 +25,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@@ -149,9 +150,9 @@ public class StarAddedListenerTest {
public void testAddingEmoteReachingThreshold() {
Long requiredStars = 1L;
setupActingAndAuthor();
when(starboardService.createStarboardPost(any(CachedMessage.class), anyList(), eq(userInServerActing), eq(userInAServer))).thenReturn(CompletableFuture.completedFuture(null));
executeAddingTest(requiredStars, null);
verify(metricService, times(2)).incrementCounter(any());
verify(starboardService, times(1)).createStarboardPost(any(CachedMessage.class), anyList(), eq(userInServerActing), eq(userInAServer));
}
@Test

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

@@ -117,6 +117,9 @@ public class StarboardServiceBeanTest {
@Mock
private AUser aUser;
@Mock
private StarboardPostCreatedListenerManager starboardPostCreatedListenerManager;
private static final Long STARRED_USER_ID = 5L;
private static final Long STARRED_SERVER_USER_ID = 2L;
private static final Long SERVER_ID = 6L;
@@ -194,13 +197,10 @@ public class StarboardServiceBeanTest {
CachedMessage message = Mockito.mock(CachedMessage.class);
List<Long> userExceptAuthorIds = Arrays.asList(FIRST_USER_IN_SERVER_ID, SECOND_USER_IN_SERVER_ID);
List<CompletableFuture<Message>> futures = Arrays.asList(CompletableFuture.completedFuture(sendPost));
when(sendPost.getGuild()).thenReturn(guild);
when(sendPost.getChannel()).thenReturn(mockedTextChannel);
when(sendPost.getIdLong()).thenReturn(MESSAGE_ID);
when(userInServerManagementService.loadUserOptional(STARRED_SERVER_USER_ID)).thenReturn(Optional.of(starredUser));
when(userInServerManagementService.loadUserOptional(FIRST_USER_IN_SERVER_ID)).thenReturn(Optional.of(userReacting));
when(userReacting.getUserInServerId()).thenReturn(FIRST_USER_IN_SERVER_ID);
when(userReacting.getUserReference()).thenReturn(aUser);
AChannel channel = Mockito.mock(AChannel.class);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(channel);
StarboardPost post = Mockito.mock(StarboardPost.class);
@@ -208,13 +208,13 @@ public class StarboardServiceBeanTest {
AUserInAServer secondStarrerUserObj = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUserOptional(SECOND_USER_IN_SERVER_ID)).thenReturn(Optional.of(secondStarrerUserObj));
when(secondStarrerUserObj.getUserInServerId()).thenReturn(SECOND_USER_IN_SERVER_ID);
when(secondStarrerUserObj.getUserReference()).thenReturn(aUser);
testUnit.persistPost(message, userExceptAuthorIds, futures, CHANNEL_ID, STARRED_SERVER_USER_ID, STARRING_USER_ID);
verify(starboardPostReactorManagementService, times(2)).addReactor(eq(post), userInAServerArgumentCaptor.capture());
List<AUserInAServer> addedReactors = userInAServerArgumentCaptor.getAllValues();
Assert.assertEquals(FIRST_USER_IN_SERVER_ID, addedReactors.get(0).getUserInServerId());
Assert.assertEquals(SECOND_USER_IN_SERVER_ID, addedReactors.get(1).getUserInServerId());
Assert.assertEquals(2, addedReactors.size());
verify(starboardPostCreatedListenerManager, times(1)).sendStarboardPostCreatedEvent(STARRING_USER_ID, post);
}
@Test
@@ -242,7 +242,7 @@ public class StarboardServiceBeanTest {
when(config.getLongValue()).thenReturn(1L);
when(defaultConfigManagementService.getDefaultConfig(StarboardFeatureConfig.STAR_LEVELS_CONFIG_KEY)).thenReturn(config);
when(defaultConfigManagementService.getDefaultConfig(StarboardFeatureConfig.STAR_LVL_CONFIG_PREFIX + 1)).thenReturn(config);
when(starboardPostManagementService.findByStarboardPostMessageId(starboardPostId)).thenReturn(Optional.of(post));
when(starboardPostManagementService.findByStarboardPostId(starboardPostId)).thenReturn(Optional.of(post));
when(userService.retrieveUserForId(STARRED_USER_ID)).thenReturn(CompletableFuture.completedFuture(starredJdaUser));
List<AUserInAServer > userExceptAuthor = new ArrayList<>();
CompletableFuture<Void> future = testUnit.updateStarboardPost(post, message, userExceptAuthor);
@@ -280,17 +280,16 @@ public class StarboardServiceBeanTest {
Integer limit = 3;
AChannel channel = Mockito.mock(AChannel.class);
when(server.getId()).thenReturn(SERVER_ID);
StarboardPostReaction reaction = Mockito.mock(StarboardPostReaction.class);
StarboardPost post1 = Mockito.mock(StarboardPost.class);
when(post1.getReactions()).thenReturn(Arrays.asList(reaction));
when(post1.getPostMessageId()).thenReturn(MESSAGE_ID);
when(post1.getServer()).thenReturn(server);
when(post1.getStarboardChannel()).thenReturn(channel);
StarboardPost post2 = Mockito.mock(StarboardPost.class);
when(post2.getPostMessageId()).thenReturn(SECOND_MESSAGE_ID);
when(post2.getReactions()).thenReturn(new ArrayList<>());
when(post2.getServer()).thenReturn(server);
when(post2.getStarboardChannel()).thenReturn(channel);
when(starboardPostReactorManagementService.getReactorCountOfPost(post1)).thenReturn(1L);
when(starboardPostReactorManagementService.getReactorCountOfPost(post2)).thenReturn(0L);
List<StarboardPost> topPosts = Arrays.asList(post1, post2);
when(starboardPostManagementService.retrieveTopPosts(SERVER_ID, limit)).thenReturn(topPosts);
CompletableFuture<StarStatsUser> statsUser = CompletableFuture.completedFuture(Mockito.mock(StarStatsUser.class));
@@ -339,10 +338,9 @@ public class StarboardServiceBeanTest {
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(post.getServer()).thenReturn(server);
StarboardPostReaction reaction = Mockito.mock(StarboardPostReaction.class);
when(post.getReactions()).thenReturn(Collections.singletonList(reaction));
when(starboardChannel.getId()).thenReturn(STARBOARD_CHANNEL_ID);
when(post.getPostMessageId()).thenReturn(MESSAGE_ID);
when(starboardPostReactorManagementService.getReactorCountOfPost(post)).thenReturn(1L);
when(starboardPostManagementService.retrieveTopPostsForUserInServer(SERVER_ID, STARRED_USER_ID, 3)).thenReturn(Collections.singletonList(post));
MemberStarStatsModel returnedModel = testUnit.retrieveStarStatsForMember(starredMember);
Assert.assertEquals(receivedStars, returnedModel.getReceivedStars());

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

@@ -13,6 +13,7 @@ import dev.sheldan.abstracto.starboard.repository.StarboardPostRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -67,14 +68,18 @@ public class StarboardPostManagementServiceBeanTest {
when(channelManagementService.loadChannel(SOURCE_CHANNEL_ID)).thenReturn(sourceChannel);
AUser aUser = Mockito.mock(AUser.class);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
ArgumentCaptor<StarboardPost> argumentCaptor = ArgumentCaptor.forClass(StarboardPost.class);
StarboardPost savedPost = Mockito.mock(StarboardPost.class);
when(repository.save(argumentCaptor.capture())).thenReturn(savedPost);
StarboardPost createdStarboardPost = testUnit.createStarboardPost(starredMessage, aUserInAServer, postInStarboard);
verify(repository, times(1)).save(createdStarboardPost);
Assert.assertEquals(starboardChannel, createdStarboardPost.getStarboardChannel());
Assert.assertEquals(starboardPostId, createdStarboardPost.getStarboardMessageId());
Assert.assertEquals(starredMessageId, createdStarboardPost.getPostMessageId());
Assert.assertEquals(aUserInAServer, createdStarboardPost.getAuthor());
Assert.assertEquals(sourceChannel, createdStarboardPost.getSourceChannel());
Assert.assertFalse(createdStarboardPost.isIgnored());
Assert.assertEquals(savedPost, createdStarboardPost);
StarboardPost capturedPost = argumentCaptor.getValue();
Assert.assertEquals(starboardChannel, capturedPost.getStarboardChannel());
Assert.assertEquals(starboardPostId, capturedPost.getStarboardMessageId());
Assert.assertEquals(starredMessageId, capturedPost.getPostMessageId());
Assert.assertEquals(aUserInAServer, capturedPost.getAuthor());
Assert.assertEquals(sourceChannel, capturedPost.getSourceChannel());
Assert.assertFalse(capturedPost.isIgnored());
}
@Test
@@ -83,20 +88,21 @@ public class StarboardPostManagementServiceBeanTest {
Long messageId = 6L;
testUnit.setStarboardPostMessageId(post, messageId);
verify(post, times(1)).setStarboardMessageId(messageId);
verify(repository, times(1)).save(post);
}
@Test
public void testRetrieveTopPosts() {
Integer count = 2;
Long postId = 1L;
Long postId2 = 3L;
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_ID)).thenReturn(posts);
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2);
List<Long> postIds = Arrays.asList(postId, postId2);
when(repository.getTopStarboardPostsForServer(SERVER_ID, count)).thenReturn(postIds);
when(repository.findAllById(postIds)).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(SERVER_ID, count);
Assert.assertEquals(count.intValue(), topPosts.size());
StarboardPost topMostPost = topPosts.get(0);
@@ -109,6 +115,9 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRetrieveMoreThanAvailable() {
Integer count = 5;
Long postId = 1L;
Long postId2 = 2L;
Long postId3 = 3L;
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);
@@ -116,7 +125,9 @@ public class StarboardPostManagementServiceBeanTest {
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_ID)).thenReturn(posts);
List<Long> postIds = Arrays.asList(postId, postId2, postId3);
when(repository.getTopStarboardPostsForServer(SERVER_ID, 5)).thenReturn(postIds);
when(repository.findAllById(postIds)).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(SERVER_ID, count);
StarboardPost topMostPost = topPosts.get(0);
StarboardPost secondTop = topPosts.get(1);
@@ -194,11 +205,9 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRetrievePostCount() {
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2);
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
Long expectedCount = 2L;
when(repository.countByServer_Id(SERVER_ID)).thenReturn(expectedCount);
Long retrievedPostCount = testUnit.getPostCount(SERVER_ID);
Assert.assertEquals(posts.size(), retrievedPostCount.intValue());
Assert.assertEquals(expectedCount, retrievedPostCount);
}
}

7
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/listener/DeleteTrackedEmoteListenerTest.java
View File

@@ -26,17 +26,12 @@ public class DeleteTrackedEmoteListenerTest {
@Mock
private EmoteDeletedModel model;
private static final Long SERVER_ID = 4L;
private static final Long EMOTE_ID = 4L;
@Test
public void testEmoteDeleted() {
Emote emote = Mockito.mock(Emote.class);
when(emote.getIdLong()).thenReturn(EMOTE_ID);
when(model.getEmote()).thenReturn(emote);
when(model.getServerId()).thenReturn(SERVER_ID);
testUnit.execute(model);
verify(trackedEmoteManagementService, times(1)).markAsDeleted(SERVER_ID, EMOTE_ID);
verify(trackedEmoteManagementService, times(1)).markAsDeleted(emote);
}
@Test

18
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/listener/EmoteTrackingListenerTest.java
View File

@@ -8,6 +8,8 @@ import dev.sheldan.abstracto.statistic.emote.service.TrackedEmoteService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.bag.HashBag;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -52,19 +54,19 @@ public class EmoteTrackingListenerTest {
@Test
public void testExecuteOneEmote() {
List<Emote> emotesBag = new ArrayList<>();
Bag<Emote> emotesBag = new HashBag<>();
emotesBag.add(emote1);
when(guildService.getGuildById(SERVER_ID)).thenReturn(guild);
when(messageReceivedModel.getMessage()).thenReturn(message);
when(messageReceivedModel.getServerId()).thenReturn(SERVER_ID);
when(message.getEmotes()).thenReturn(emotesBag);
when(message.getEmotesBag()).thenReturn(emotesBag);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(emote1, guild, 1L);
}
@Test
public void testExecuteOneEmoteMultipleTimes() {
List<Emote> emotesBag = new ArrayList<>();
Bag<Emote> emotesBag = new HashBag<>();
when(emote1.getIdLong()).thenReturn(EMOTE_ID);
when(emote2.getIdLong()).thenReturn(EMOTE_ID);
emotesBag.add(emote1);
@@ -72,14 +74,14 @@ public class EmoteTrackingListenerTest {
when(guildService.getGuildById(SERVER_ID)).thenReturn(guild);
when(messageReceivedModel.getServerId()).thenReturn(SERVER_ID);
when(messageReceivedModel.getMessage()).thenReturn(message);
when(message.getEmotes()).thenReturn(emotesBag);
when(message.getEmotesBag()).thenReturn(emotesBag);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(any(CachedEmote.class), eq(guild), eq(2L));
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(any(Emote.class), eq(guild), eq(2L));
}
@Test
public void testExecuteMultipleEmotes() {
List<Emote> emotesBag = new ArrayList<>();
Bag<Emote> emotesBag = new HashBag<>();
when(emote1.getIdLong()).thenReturn(EMOTE_ID);
when(emote2.getIdLong()).thenReturn(EMOTE_ID + 1);
emotesBag.add(emote1);
@@ -87,7 +89,7 @@ public class EmoteTrackingListenerTest {
when(guildService.getGuildById(SERVER_ID)).thenReturn(guild);
when(messageReceivedModel.getServerId()).thenReturn(SERVER_ID);
when(messageReceivedModel.getMessage()).thenReturn(message);
when(message.getEmotes()).thenReturn(emotesBag);
when(message.getEmotesBag()).thenReturn(emotesBag);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(emote1, guild, 1L);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(emote2, guild, 1L);
@@ -95,7 +97,7 @@ public class EmoteTrackingListenerTest {
@Test
public void testExecuteNoEmote() {
when(message.getEmotes()).thenReturn(new ArrayList<>());
when(message.getEmotesBag()).thenReturn(new HashBag<>());
when(messageReceivedModel.getMessage()).thenReturn(message);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(0)).addEmoteToRuntimeStorage(any(Emote.class), any(), anyLong());

5
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/listener/UpdateTrackedEmoteListenerTest.java
View File

@@ -29,12 +29,9 @@ public class UpdateTrackedEmoteListenerTest {
@Test
public void testEmoteUpdated() {
Long serverId = 1L;
Long emoteId = 2L;
Emote changedEmote = Mockito.mock(Emote.class);
when(changedEmote.getIdLong()).thenReturn(emoteId);
TrackedEmote trackedEmote = Mockito.mock(TrackedEmote.class);
when(trackedEmoteManagementService.loadByEmoteId(emoteId, serverId)).thenReturn(trackedEmote);
when(trackedEmoteManagementService.loadByEmote(changedEmote)).thenReturn(trackedEmote);
String newValue = "AFTER";
when(model.getEmote()).thenReturn(changedEmote);
when(model.getNewValue()).thenReturn(newValue);

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

@@ -17,6 +17,7 @@ import net.dv8tion.jda.api.entities.MessageChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -70,11 +71,15 @@ public class SuggestionManagementServiceBeanTest {
when(message.getGuild()).thenReturn(guild);
when(guild.getId()).thenReturn("8");
long suggestionId = 1L;
ArgumentCaptor<Suggestion> suggestionArgumentCaptor = ArgumentCaptor.forClass(Suggestion.class);
Suggestion savedSuggestion = Mockito.mock(Suggestion.class);
when(suggestionRepository.save(suggestionArgumentCaptor.capture())).thenReturn(savedSuggestion);
Suggestion createdSuggestion = testUnit.createSuggestion(aUserInAServer, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);
Assert.assertEquals(SuggestionState.NEW, createdSuggestion.getState());
Assert.assertEquals(aUserInAServer, createdSuggestion.getSuggester());
Assert.assertEquals(server, createdSuggestion.getServer());
Assert.assertEquals(savedSuggestion, createdSuggestion);
Suggestion capturedSuggestion = suggestionArgumentCaptor.getValue();
Assert.assertEquals(SuggestionState.NEW, capturedSuggestion.getState());
Assert.assertEquals(aUserInAServer, capturedSuggestion.getSuggester());
Assert.assertEquals(server, capturedSuggestion.getServer());
}
@Test
@@ -92,11 +97,15 @@ public class SuggestionManagementServiceBeanTest {
when(guild.getId()).thenReturn("5");
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(aUserInAServer);
long suggestionId = 1L;
ArgumentCaptor<Suggestion> suggestionArgumentCaptor = ArgumentCaptor.forClass(Suggestion.class);
Suggestion savedSuggestion = Mockito.mock(Suggestion.class);
when(suggestionRepository.save(suggestionArgumentCaptor.capture())).thenReturn(savedSuggestion);
Suggestion createdSuggestion = testUnit.createSuggestion(member, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);
Assert.assertEquals(SuggestionState.NEW, createdSuggestion.getState());
Assert.assertEquals(aUserInAServer, createdSuggestion.getSuggester());
Assert.assertEquals(server, createdSuggestion.getServer());
Assert.assertEquals(savedSuggestion, createdSuggestion);
Suggestion capturedSuggestion = suggestionArgumentCaptor.getValue();
Assert.assertEquals(SuggestionState.NEW, capturedSuggestion.getState());
Assert.assertEquals(aUserInAServer, capturedSuggestion.getSuggester());
Assert.assertEquals(server, capturedSuggestion.getServer());
}
@Test