diff --git a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBean.java b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBean.java index 591d2a430..defa3780c 100644 --- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBean.java +++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBean.java @@ -31,7 +31,7 @@ public class ChannelGroupCommandManagementServiceBean implements ChannelGroupCom @Override public void addCommandToGroup(ACommand command, AChannelGroup group) { Optional groupCommandOptional = groupCommandRepository.findByCommandAndGroup(command, group); - if(!groupCommandOptional.isPresent()) { + if(groupCommandOptional.isEmpty()) { createCommandInGroup(command, group); } } @@ -39,7 +39,7 @@ public class ChannelGroupCommandManagementServiceBean implements ChannelGroupCom @Override public void removeCommandFromGroup(ACommand command, AChannelGroup group) { Optional groupCommandOptional = groupCommandRepository.findByCommandAndGroup(command, group); - if(!groupCommandOptional.isPresent()) { + if(groupCommandOptional.isEmpty()) { throw new CommandNotFoundInGroupException(); } groupCommandOptional.ifPresent(channelGroupCommand -> groupCommandRepository.delete(channelGroupCommand)); diff --git a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBean.java b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBean.java index cc706416a..0ea22b2b1 100644 --- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBean.java +++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBean.java @@ -34,6 +34,6 @@ public class CommandDisabledChannelGroupManagementServiceBean implements Command @Override public CommandDisabledChannelGroup findViaChannelGroup(AChannelGroup channelGroup) { - return commandDisabledChannelGroupRepository.getOne(channelGroup.getId()); + return commandDisabledChannelGroupRepository.getReferenceById(channelGroup.getId()); } } diff --git a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBean.java b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBean.java index 096557a61..dc98fce53 100644 --- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBean.java +++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBean.java @@ -22,11 +22,6 @@ public class CommandInServerManagementServiceBean implements CommandInServerMana @Override public ACommandInAServer createCommandInServer(ACommand command, AServer server) { - return createCommandInServer(command, server, null); - } - - @Override - public ACommandInAServer createCommandInServer(ACommand command, AServer server, Long commandId) { ACommandInAServer commandInAServer = ACommandInAServer .builder() .commandReference(command) @@ -60,7 +55,7 @@ public class CommandInServerManagementServiceBean implements CommandInServerMana @Override public ACommandInAServer getCommandForServer(Long commandInServerId) { - return repository.getOne(commandInServerId); + return repository.getReferenceById(commandInServerId); } @Override diff --git a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBean.java b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBean.java index 84e1b9bc4..4d1280c59 100644 --- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBean.java +++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBean.java @@ -16,22 +16,9 @@ import java.util.Optional; @Slf4j public class CommandManagementServiceBean implements CommandManagementService { - @Autowired - private ModuleManagementService moduleManagementService; - @Autowired private CommandRepository commandRepository; - @Autowired - private FeatureManagementService featureManagementService; - - @Override - public ACommand createCommand(String name, String moduleName, String featureName) { - AModule module = moduleManagementService.findModuleByName(moduleName); - AFeature feature = featureManagementService.getFeature(featureName); - return createCommand(name, module, feature); - } - @Override public ACommand createCommand(String name, AModule module, AFeature feature) { ACommand command = ACommand diff --git a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBean.java b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBean.java index 3f5944fbc..f6ff959c1 100644 --- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBean.java +++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBean.java @@ -27,11 +27,11 @@ public class CoolDownChannelGroupManagementServiceBean implements CoolDownChanne @Override public CoolDownChannelGroup findByChannelGroupId(Long channelGroupId) { - return repository.getOne(channelGroupId); + return repository.getReferenceById(channelGroupId); } @Override public void deleteCoolDownChannelGroup(AChannelGroup aChannelGroup) { - repository.delete(findByChannelGroupId(aChannelGroup.getId())); + repository.deleteById(aChannelGroup.getId()); } } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImplTest.java index d0ce8ffcf..83d9ae433 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImplTest.java @@ -53,6 +53,7 @@ public class AChannelParameterHandlerImplTest extends AbstractParameterHandlerTe @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(AChannel.class, unparsedCommandParameterPiece)).isTrue(); } @@ -66,7 +67,9 @@ public class AChannelParameterHandlerImplTest extends AbstractParameterHandlerTe UnparsedCommandParameterPiece piece = getPiece(); when(textChannelParameterHandler.handle(piece, iterators, parameter, message, command)).thenReturn(channel); when(channelService.getFakeChannelFromTextChannel(channel)).thenReturn(aChannel); + AChannel parsed = (AChannel) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed).isEqualTo(aChannel); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerImplImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerImplImplTest.java index 731b9acfc..da8b8eea5 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerImplImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerImplImplTest.java @@ -75,7 +75,9 @@ public class AEmoteParameterHandlerImplImplTest extends AbstractParameterHandler when(commandService.cloneParameter(parameter)).thenReturn(parameter2); when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(emote); when(emoteService.getFakeEmoteFromEmote(emote)).thenReturn(aEmote); + AEmote parsed = (AEmote) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed).isEqualTo(aEmote); } @@ -85,7 +87,9 @@ public class AEmoteParameterHandlerImplImplTest extends AbstractParameterHandler when(commandService.cloneParameter(parameter)).thenReturn(parameter2); when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(null); when(emoteService.getFakeEmote(INPUT)).thenReturn(aEmote); + AEmote parsed = (AEmote) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed).isEqualTo(aEmote); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImplImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImplImplTest.java index d85018fc9..6b5f422a4 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImplImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImplImplTest.java @@ -60,6 +60,7 @@ public class ARoleParameterHandlerImplImplTest extends AbstractParameterHandlerT @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(ARole.class, unparsedCommandParameterPiece)).isTrue(); } @@ -74,7 +75,9 @@ public class ARoleParameterHandlerImplImplTest extends AbstractParameterHandlerT when(commandService.cloneParameter(parameter)).thenReturn(parameter2); when(roleParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(role); when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole); + ARole parsed = (ARole) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed).isEqualTo(aRole); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerImplTest.java index c871cb5f6..dbcc4282c 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerImplTest.java @@ -31,6 +31,7 @@ public class BooleanParameterHandlerImplTest extends AbstractParameterHandlerTes @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(Boolean.class, unparsedCommandParameterPiece)).isTrue(); } @@ -42,18 +43,21 @@ public class BooleanParameterHandlerImplTest extends AbstractParameterHandlerTes @Test public void testTrueParsing() { UnparsedCommandParameterPiece piece = getPieceWithValue("true"); + assertThat((Boolean)testUnit.handle(piece, null, parameter, null, command)).isTrue(); } @Test public void testAnyOtherText() { UnparsedCommandParameterPiece piece = getPieceWithValue("test"); + assertThat((Boolean)testUnit.handle(piece, null, parameter, null, command)).isFalse(); } @Test public void testEmptyStringAsInput() { UnparsedCommandParameterPiece piece = getPieceWithValue(""); + assertThat((Boolean)testUnit.handle(piece, null, parameter, null, command)).isFalse(); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerImplTest.java index 17ce9cc5f..05ef7db0e 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerImplTest.java @@ -31,6 +31,7 @@ public class DoubleParameterHandlerImplTest extends AbstractParameterHandlerTest @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(Double.class, unparsedCommandParameterPiece)).isTrue(); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerImplTest.java index 92c5db4d8..c6e8ac829 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerImplTest.java @@ -36,6 +36,7 @@ public class DurationParameterHandlerImplTest extends AbstractParameterHandlerTe @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(Duration.class, unparsedCommandParameterPiece)).isTrue(); } @@ -52,6 +53,7 @@ public class DurationParameterHandlerImplTest extends AbstractParameterHandlerTe @Test public void testMoreComplicatedParsing() { Duration targetDuration = Duration.ofDays(4).plus(5, ChronoUnit.HOURS).plus(5, ChronoUnit.MINUTES); + assertThat(testUnit.handle(getPieceWithValue("5h5m4d"), null, parameter, null, command)).isEqualTo(targetDuration); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerImplTest.java index 63621e1a8..1ee6cec2f 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerImplTest.java @@ -53,6 +53,7 @@ public class EmoteParameterHandlerImplTest extends AbstractParameterHandlerTest @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(CustomEmoji.class, unparsedCommandParameterPiece)).isTrue(); } @@ -65,7 +66,9 @@ public class EmoteParameterHandlerImplTest extends AbstractParameterHandlerTest public void testProperEmoteMention() { oneEmoteInIterator(); String input = getEmoteMention(); + CustomEmoji parsed = (CustomEmoji) testUnit.handle(getPieceWithValue(input), iterators, parameter, null, command); + assertThat(parsed).isEqualTo(emote); } @@ -73,7 +76,9 @@ public class EmoteParameterHandlerImplTest extends AbstractParameterHandlerTest public void testEmoteById() { setupMessage(); String input = EMOTE_ID.toString(); + CustomEmoji parsed = (CustomEmoji) testUnit.handle(getPieceWithValue(input), null, parameter, message, command); + assertThat(parsed).isEqualTo(emote); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerImplImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerImplImplTest.java index 66f8c21fc..f937fc8d6 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerImplImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerImplImplTest.java @@ -61,6 +61,7 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(FullEmote.class, unparsedCommandParameterPiece)).isTrue(); } @@ -76,7 +77,9 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand when(commandService.cloneParameter(parameter)).thenReturn(parameter2); when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(emote); when(emoteService.getFakeEmoteFromEmote(emote)).thenReturn(aEmote); + FullEmote parsed = (FullEmote) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed.getFakeEmote()).isEqualTo(aEmote); assertThat(parsed.getEmote()).isEqualTo(emote); } @@ -89,7 +92,9 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand when(commandService.cloneParameter(parameter)).thenReturn(parameter2); when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(null); when(emoteService.getFakeEmote(input)).thenReturn(aEmote); + FullEmote parsed = (FullEmote) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed.getEmote()).isNull(); assertThat(parsed.getFakeEmote()).isEqualTo(aEmote); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImplImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImplImplTest.java index 2aef88eff..b2cea5237 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImplImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImplImplTest.java @@ -61,6 +61,7 @@ public class FullRoleParameterHandlerImplImplTest extends AbstractParameterHandl @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(FullRole.class, unparsedCommandParameterPiece)).isTrue(); } @@ -75,7 +76,9 @@ public class FullRoleParameterHandlerImplImplTest extends AbstractParameterHandl when(commandService.cloneParameter(parameter)).thenReturn(parameter2); when(roleParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(role); when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole); + FullRole parsed = (FullRole) testUnit.handle(piece, iterators, parameter, message, command); + assertThat(parsed.getRole()).isEqualTo(aRole); assertThat(parsed.getServerRole()).isEqualTo(role); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerImplTest.java index 23949b0d3..aa9dced02 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerImplTest.java @@ -32,6 +32,7 @@ public class IntegerParameterHandlerImplTest extends AbstractParameterHandlerTes @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(Integer.class, unparsedCommandParameterPiece)).isTrue(); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerImplTest.java index 9c65e65f0..8085956db 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerImplTest.java @@ -32,6 +32,7 @@ public class LongParameterHandlerImplTest extends AbstractParameterHandlerTest { @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(Long.class, unparsedCommandParameterPiece)).isTrue(); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerImplTest.java index fa4f78919..c629349c0 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerImplTest.java @@ -56,6 +56,7 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest @Test public void testSuccessfulCondition() { when(unparsedCommandParameterPiece.getType()).thenReturn(ParameterPieceType.STRING); + assertThat(testUnit.handles(Member.class, unparsedCommandParameterPiece)).isTrue(); } @@ -69,7 +70,9 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest public void testProperMemberMention() { oneMemberInIterator(); String input = getUserMention(); + CompletableFuture parsed = (CompletableFuture) testUnit.handleAsync(getPieceWithValue(input), iterators, parameter, null, command); + assertThat(parsed.join()).isEqualTo(member); } @@ -78,7 +81,9 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest public void testMemberById() { setupMessage(); String input = USER_ID.toString(); + CompletableFuture parsed = (CompletableFuture) testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command); + assertThat(parsed.join()).isEqualTo(member); } @@ -88,7 +93,9 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest when(message.getGuild()).thenReturn(guild); GatewayTask task = new GatewayTask(CompletableFuture.completedFuture(new ArrayList()), () -> {}); when(guild.retrieveMembersByPrefix(input, 1)).thenReturn(task); + CompletableFuture future = testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command); + assertThat(future.isCompletedExceptionally()).isTrue(); } @@ -99,7 +106,9 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest when(message.getGuild()).thenReturn(guild); GatewayTask task = new GatewayTask(CompletableFuture.completedFuture(Arrays.asList(member, secondMember)), () -> {}); when(guild.retrieveMembersByPrefix(input, 1)).thenReturn(task); + CompletableFuture future = testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command); + assertThat(future.isCompletedExceptionally()).isTrue(); } @@ -109,7 +118,9 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest when(message.getGuild()).thenReturn(guild); GatewayTask task = new GatewayTask(CompletableFuture.completedFuture(Arrays.asList(member)), () -> {}); when(guild.retrieveMembersByPrefix(input, 1)).thenReturn(task); + CompletableFuture future = testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command); + Member returnedMember = (Member) future.join(); assertThat(future.isCompletedExceptionally()).isFalse(); assertThat(returnedMember).isEqualTo(member); diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerImplTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerImplTest.java index 055c08034..6366b3134 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerImplTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerImplTest.java @@ -66,7 +66,9 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest { public void testProperRoleMention() { setupMessage(); String input = getRoleMention(); + Role parsed = (Role) testUnit.handle(getPieceWithValue(input), iterators, parameter, message, command); + assertThat(parsed).isEqualTo(role); } @@ -74,7 +76,9 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest { public void testRoleById() { setupMessage(); String input = ROLE_ID.toString(); + Role parsed = (Role) testUnit.handle(getPieceWithValue(input), null, parameter, message, command); + assertThat(parsed).isEqualTo(role); } @@ -83,6 +87,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest { String input = "test"; when(message.getGuild()).thenReturn(guild); when(guild.getRolesByName(input, true)).thenReturn(new ArrayList<>()); + assertThatThrownBy(() -> { testUnit.handle(getPieceWithValue(input), null, parameter, message, command); }).isInstanceOf(AbstractoTemplatedException.class); @@ -95,6 +100,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest { Role secondRole = Mockito.mock(Role.class); when(message.getGuild()).thenReturn(guild); when(guild.getRolesByName(input, true)).thenReturn(Arrays.asList(role, secondRole)); + assertThatThrownBy(() -> { testUnit.handle(getPieceWithValue(input), null, parameter, message, command); }).isInstanceOf(AbstractoTemplatedException.class); @@ -105,7 +111,9 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest { String input = "test"; when(message.getGuild()).thenReturn(guild); when(guild.getRolesByName(input, true)).thenReturn(Arrays.asList(role)); + Role returnedRole = (Role) testUnit.handle(getPieceWithValue(input), null, parameter, message, command); + assertThat(returnedRole).isEqualTo(role); } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBeanTest.java new file mode 100644 index 000000000..e6586b6aa --- /dev/null +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBeanTest.java @@ -0,0 +1,188 @@ +package dev.sheldan.abstracto.core.command.service.management; + +import dev.sheldan.abstracto.core.command.exception.CommandNotFoundInGroupException; +import dev.sheldan.abstracto.core.command.model.database.ACommand; +import dev.sheldan.abstracto.core.command.repository.ChannelGroupCommandRepository; +import dev.sheldan.abstracto.core.models.database.AChannelGroup; +import dev.sheldan.abstracto.core.models.database.AChannelGroupCommand; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ChannelGroupCommandManagementServiceBeanTest { + + @InjectMocks + private ChannelGroupCommandManagementServiceBean unitToTest; + + @Mock + private ChannelGroupCommandRepository repository; + + @Test + public void allGroupsForCommand() { + List channelGroupCommands = channelGroupCommands(); + ACommand aCommand = aCommand(); + when(repository.findByCommand(aCommand)).thenReturn(channelGroupCommands); + + assertThat(unitToTest.getAllGroupCommandsForCommand(aCommand)).isEqualTo(channelGroupCommands); + } + + @Test + public void allGroupsForCommandAndGroups() { + List channelGroups = getChannelGroups(); + ACommand aCommand = aCommand(); + List channelGroupCommands = channelGroupCommands(); + when(repository.findByCommandAndGroupIn(aCommand, channelGroups)).thenReturn(channelGroupCommands); + + assertThat(unitToTest.getAllGroupCommandsForCommandInGroups(aCommand, channelGroups)).isEqualTo(channelGroupCommands); + } + + @Test + public void allGroupsForCommandsAndGroupsOfType() { + ACommand aCommand = aCommand(); + List channelGroupCommands = channelGroupCommands(); + String channelGroupType = "test"; + when(repository.findByCommandAndGroup_ChannelGroupType_GroupTypeKey(aCommand, channelGroupType)).thenReturn(channelGroupCommands); + + assertThat(unitToTest.getAllGroupCommandsForCommandWithType(aCommand, channelGroupType)).isEqualTo(channelGroupCommands); + } + + @Test + public void getChannelGroupCommand() { + ACommand aCommand = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + AChannelGroupCommand aChannelGroupCommand = aChannelGroupCommand(); + when(repository.findByCommandAndGroup(aCommand, aChannelGroup)).thenReturn(Optional.of(aChannelGroupCommand)); + + assertThat(unitToTest.getChannelGroupCommand(aCommand, aChannelGroup)).isEqualTo(aChannelGroupCommand); + } + + @Test + public void getChannelGroupCommandNotFound() { + ACommand command = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + when(repository.findByCommandAndGroup(command, aChannelGroup)).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> { + unitToTest.getChannelGroupCommand(command, aChannelGroup); + }).isInstanceOf(CommandNotFoundInGroupException.class); + } + + @Test + public void createCommandInGroup() { + ACommand aCommand = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + ArgumentCaptor channelGroupCommandArgumentCaptor = ArgumentCaptor.forClass(AChannelGroupCommand.class); + + unitToTest.createCommandInGroup(aCommand, aChannelGroup); + + verify(repository).save(channelGroupCommandArgumentCaptor.capture()); + AChannelGroupCommand aChannelGroupCommand = channelGroupCommandArgumentCaptor.getValue(); + assertThat(aChannelGroupCommand.getCommand()).isEqualTo(aCommand); + assertThat(aChannelGroupCommand.getEnabled()).isTrue(); + assertThat(aChannelGroupCommand.getGroup()).isEqualTo(aChannelGroup); + } + + @Test + public void removeCommandFromGroup() { + ACommand aCommand = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + AChannelGroupCommand aChannelGroupCommand = aChannelGroupCommand(); + when(repository.findByCommandAndGroup(aCommand, aChannelGroup)).thenReturn(Optional.of(aChannelGroupCommand)); + + unitToTest.removeCommandFromGroup(aCommand, aChannelGroup); + + verify(repository).delete(aChannelGroupCommand); + } + + @Test + public void removeCommandFromGroupNotFound() { + ACommand aCommand = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + when(repository.findByCommandAndGroup(aCommand, aChannelGroup)).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> { + unitToTest.removeCommandFromGroup(aCommand, aChannelGroup); + }).isInstanceOf(CommandNotFoundInGroupException.class); + } + + @Test + public void addCommandToGroup() { + ACommand aCommand = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + when(repository.findByCommandAndGroup(aCommand, aChannelGroup)).thenReturn(Optional.empty()); + + unitToTest.addCommandToGroup(aCommand, aChannelGroup); + + ArgumentCaptor channelGroupCommandArgumentCaptor = ArgumentCaptor.forClass(AChannelGroupCommand.class); + verify(repository).save(channelGroupCommandArgumentCaptor.capture()); + AChannelGroupCommand aChannelGroupCommand = channelGroupCommandArgumentCaptor.getValue(); + assertThat(aChannelGroupCommand.getCommand()).isEqualTo(aCommand); + assertThat(aChannelGroupCommand.getEnabled()).isTrue(); + assertThat(aChannelGroupCommand.getGroup()).isEqualTo(aChannelGroup); + } + + @Test + public void setCommandInGroupEnabledNotExistingToFalse() { + ACommand aCommand = aCommand(); + AChannelGroup aChannelGroup = aChannelGroup(); + when(repository.findByCommandAndGroup(aCommand, aChannelGroup)).thenReturn(Optional.empty()); + AChannelGroupCommand aChannelGroupCommand = aChannelGroupCommand(); + when(repository.save(any())).thenReturn(aChannelGroupCommand); + + unitToTest.setCommandInGroupTo(aCommand, aChannelGroup, false); + + ArgumentCaptor channelGroupCommandArgumentCaptor = ArgumentCaptor.forClass(AChannelGroupCommand.class); + verify(repository).save(channelGroupCommandArgumentCaptor.capture()); + AChannelGroupCommand savedChannelGroupCommand = channelGroupCommandArgumentCaptor.getValue(); + assertThat(savedChannelGroupCommand.getCommand()).isEqualTo(aCommand); + assertThat(savedChannelGroupCommand.getEnabled()).isTrue(); + assertThat(savedChannelGroupCommand.getGroup()).isEqualTo(aChannelGroup); + assertThat(aChannelGroupCommand.getEnabled()).isFalse(); + } + + + private ACommand aCommand() { + return ACommand + .builder() + .build(); + } + + + private List channelGroupCommands() { + return Collections.singletonList(AChannelGroupCommand + .builder() + .build()); + } + + private AChannelGroupCommand aChannelGroupCommand() { + return AChannelGroupCommand + .builder() + .build(); + } + + private List getChannelGroups() { + return Collections.singletonList(AChannelGroup + .builder() + .build()); + } + + private AChannelGroup aChannelGroup() { + return AChannelGroup + .builder() + .build(); + } +} diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBeanTest.java new file mode 100644 index 000000000..be8691677 --- /dev/null +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandDisabledChannelGroupManagementServiceBeanTest.java @@ -0,0 +1,78 @@ +package dev.sheldan.abstracto.core.command.service.management; + +import dev.sheldan.abstracto.core.command.model.database.CommandDisabledChannelGroup; +import dev.sheldan.abstracto.core.command.repository.CommandDisabledChannelGroupRepository; +import dev.sheldan.abstracto.core.models.database.AChannelGroup; +import dev.sheldan.abstracto.core.models.database.AServer; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class CommandDisabledChannelGroupManagementServiceBeanTest { + + @InjectMocks + private CommandDisabledChannelGroupManagementServiceBean unitToTest; + + @Mock + private CommandDisabledChannelGroupRepository repository; + + private static final Long CHANNEL_GROUP_ID = 1L; + + @Test + public void findViaChannelGroup() { + AChannelGroup aChannelGroup = aChannelGroup(); + CommandDisabledChannelGroup aCommandDisabledChannelGroup = aCommandDisabledChannelGroup(); + when(repository.getReferenceById(CHANNEL_GROUP_ID)).thenReturn(aCommandDisabledChannelGroup); + + CommandDisabledChannelGroup viaChannelGroup = unitToTest.findViaChannelGroup(aChannelGroup); + + assertThat(viaChannelGroup).isEqualTo(aCommandDisabledChannelGroup); + } + + @Test + public void testDeleteCommandDisabledChannelGroup() { + unitToTest.deleteCommandDisabledChannelGroup(aChannelGroup()); + + verify(repository).deleteById(CHANNEL_GROUP_ID); + } + + @Test + public void testCreateCommandDisabledChannelGroup() { + + AChannelGroup aChannelGroup = aChannelGroup(); + + unitToTest.createCommandDisabledChannelGroup(aChannelGroup); + + ArgumentCaptor commandDisabledChannelGroupArgumentCaptor = ArgumentCaptor.forClass(CommandDisabledChannelGroup.class); + verify(repository).save(commandDisabledChannelGroupArgumentCaptor.capture()); + CommandDisabledChannelGroup commandDisabledChannelGroup = commandDisabledChannelGroupArgumentCaptor.getValue(); + assertThat(commandDisabledChannelGroup.getId()).isEqualTo(CHANNEL_GROUP_ID); + assertThat(commandDisabledChannelGroup.getChannelGroup()).isEqualTo(aChannelGroup); + } + + private AChannelGroup aChannelGroup() { + AServer server = AServer + .builder() + .build(); + + return AChannelGroup + .builder() + .id(CHANNEL_GROUP_ID) + .server(server) + .build(); + } + + private CommandDisabledChannelGroup aCommandDisabledChannelGroup() { + return CommandDisabledChannelGroup + .builder() + .build(); + } +} diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerAliasManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerAliasManagementServiceBeanTest.java index 663253077..21ac5b4c0 100644 --- a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerAliasManagementServiceBeanTest.java +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerAliasManagementServiceBeanTest.java @@ -4,7 +4,6 @@ import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer; import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias; import dev.sheldan.abstracto.core.command.repository.CommandInServerAliasRepository; import dev.sheldan.abstracto.core.models.database.AServer; -import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; @@ -17,6 +16,7 @@ import java.util.Arrays; import java.util.List; import java.util.Optional; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.*; @RunWith(MockitoJUnitRunner.class) @@ -40,38 +40,46 @@ public class CommandInServerAliasManagementServiceBeanTest { @Test public void testGetAliasesInServer() { when(repository.findByCommandInAServer_ServerReference(server)).thenReturn(Arrays.asList(alias)); + List foundAliases = testUnit.getAliasesInServer(server); - Assert.assertEquals(1, foundAliases.size()); - Assert.assertEquals(alias, foundAliases.get(0)); + + assertThat(foundAliases).hasSize(1); + assertThat(foundAliases.get(0)).isEqualTo(alias); } @Test public void testDoesCommandInServerAliasExist() { when(repository.existsByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(true); - Assert.assertTrue(testUnit.doesCommandInServerAliasExist(server, ALIAS_NAME)); + + assertThat(testUnit.doesCommandInServerAliasExist(server, ALIAS_NAME)).isTrue(); } @Test public void testDoesCommandInServerAliasNotExist() { when(repository.existsByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(false); - Assert.assertFalse(testUnit.doesCommandInServerAliasExist(server, ALIAS_NAME)); + + assertThat(testUnit.doesCommandInServerAliasExist(server, ALIAS_NAME)).isFalse(); } @Test public void testGetCommandInServerAlias() { when(repository.findByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(Optional.of(alias)); + Optional commandOptional = testUnit.getCommandInServerAlias(server, ALIAS_NAME); - Assert.assertTrue(commandOptional.isPresent()); + + assertThat(commandOptional.isPresent()).isTrue(); commandOptional.ifPresent(existingAlias -> - Assert.assertEquals(alias, existingAlias) + assertThat(existingAlias).isEqualTo(alias) ); } @Test public void testGetCommandInServerAliasNotExist() { when(repository.findByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(Optional.empty()); + Optional commandOptional = testUnit.getCommandInServerAlias(server, ALIAS_NAME); - Assert.assertFalse(commandOptional.isPresent()); + + assertThat(commandOptional.isPresent()).isFalse(); } @Test @@ -80,23 +88,28 @@ public class CommandInServerAliasManagementServiceBeanTest { ArgumentCaptor aliasArgumentCaptor = ArgumentCaptor.forClass(ACommandInServerAlias.class); ACommandInServerAlias savedAlias = Mockito.mock(ACommandInServerAlias.class); when(repository.save(aliasArgumentCaptor.capture())).thenReturn(savedAlias); + ACommandInServerAlias createdAlias = testUnit.createAliasForCommand(commandInAServer, ALIAS_NAME); - Assert.assertEquals(savedAlias, createdAlias); + + assertThat(createdAlias).isEqualTo(savedAlias); ACommandInServerAlias capturedAlias = aliasArgumentCaptor.getValue(); - Assert.assertEquals(commandInAServer, capturedAlias.getCommandInAServer()); + assertThat(capturedAlias.getCommandInAServer()).isEqualTo(commandInAServer); } @Test public void testDeleteCommandInServerAlias() { testUnit.deleteCommandInServerAlias(alias); + verify(repository, times(1)).delete(alias); } @Test public void testGetAliasesForCommandInServer() { when(repository.findByCommandInAServer_ServerReferenceAndCommandInAServer_CommandReference_NameEqualsIgnoreCase(server, COMMAND_NAME)).thenReturn(Arrays.asList(alias)); + List foundAliases = testUnit.getAliasesForCommandInServer(server, COMMAND_NAME); - Assert.assertEquals(1, foundAliases.size()); - Assert.assertEquals(alias, foundAliases.get(0)); + + assertThat(foundAliases).hasSize(1); + assertThat(foundAliases.get(0)).isEqualTo(alias); } } diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBeanTest.java new file mode 100644 index 000000000..191a0b06f --- /dev/null +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBeanTest.java @@ -0,0 +1,146 @@ +package dev.sheldan.abstracto.core.command.service.management; + +import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException; +import dev.sheldan.abstracto.core.command.model.database.ACommand; +import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer; +import dev.sheldan.abstracto.core.command.repository.CommandInServerRepository; +import dev.sheldan.abstracto.core.models.database.AServer; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import java.time.Duration; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.*; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class CommandInServerManagementServiceBeanTest { + @InjectMocks + private CommandInServerManagementServiceBean unitToTest; + + @Mock + private CommandInServerRepository repository; + + private static final Long COMMAND_ID = 1L; + private static final Long SERVER_ID = 2L; + + @Test + public void getCommandsFromServer() { + List commandIds = Arrays.asList(COMMAND_ID); + List commandsInServer = commandsInServer(); + when(repository.findAllById(commandIds)).thenReturn(commandsInServer); + + assertThat(unitToTest.getCommandsForServer(commandIds)).isEqualTo(commandsInServer); + } + + @Test + public void getCommandForServerViaId() { + ACommandInAServer aCommandInServer = aCommandInAServer(); + when(repository.getReferenceById(COMMAND_ID)).thenReturn(aCommandInServer); + + assertThat(unitToTest.getCommandForServer(COMMAND_ID)).isEqualTo(aCommandInServer); + } + + @Test + public void getCommandForServerViaServerId() { + ACommand aCommand = aCommand(); + ACommandInAServer aCommandInServer = aCommandInAServer(); + when(repository.findByServerReference_IdAndCommandReference(SERVER_ID, aCommand)).thenReturn(aCommandInServer); + + assertThat(unitToTest.getCommandForServer(aCommand, SERVER_ID)).isEqualTo(aCommandInServer); + } + + @Test + public void getCommandForServerViaServerObj() { + ACommand aCommand = aCommand(); + AServer aServer = aServer(); + ACommandInAServer aCommandInServer = aCommandInAServer(); + when(repository.findByServerReferenceAndCommandReference(aServer, aCommand)).thenReturn(Optional.of(aCommandInServer)); + + assertThat(unitToTest.getCommandForServer(aCommand, aServer)).isEqualTo(aCommandInServer); + } + + @Test + public void getCommandNotFoundForServerViaServerObj() { + ACommand aCommand = aCommand(); + AServer aServer = aServer(); + ACommandInAServer aCommandInServer = aCommandInAServer(); + when(repository.findByServerReferenceAndCommandReference(aServer, aCommand)).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> { + assertThat(unitToTest.getCommandForServer(aCommand, aServer)).isEqualTo(aCommandInServer); + }).isInstanceOf(CommandNotFoundException.class); + } + + @Test + public void setMemberCoolDownForCommandInServer() { + ACommand aCommand = aCommand(); + AServer aServer = aServer(); + Duration duration = Duration.ofMinutes(1); + ACommandInAServer aCommandInServer = aCommandInAServer(); + when(repository.findByServerReferenceAndCommandReference(aServer, aCommand)).thenReturn(Optional.of(aCommandInServer)); + + unitToTest.setCooldownForCommandInServer(aCommand, aServer, duration); + + assertThat(aCommandInServer.getMemberCooldown()).isEqualTo(duration); + } + + @Test + public void doesCommandExistInServer() { + ACommand aCommand = aCommand(); + AServer aServer = aServer(); + ACommandInAServer aCommandInServer = aCommandInAServer(); + when(repository.findByServerReferenceAndCommandReference(aServer, aCommand)).thenReturn(Optional.of(aCommandInServer)); + + assertThat(unitToTest.doesCommandExistInServer(aCommand, aServer)).isTrue(); + } + + @Test + public void createCommandInServer() { + ACommand aCommand = aCommand(); + AServer aServer = aServer(); + ArgumentCaptor commandInAServerArgumentCaptor = ArgumentCaptor.forClass(ACommandInAServer.class); + + unitToTest.createCommandInServer(aCommand, aServer); + + verify(repository).save(commandInAServerArgumentCaptor.capture()); + ACommandInAServer aCommandInServer = commandInAServerArgumentCaptor.getValue(); + assertThat(aCommandInServer.getServerReference()).isEqualTo(aServer); + assertThat(aCommandInServer.getCommandReference()).isEqualTo(aCommand); + assertThat(aCommandInServer.getCoolDown()).isEqualTo(0L); + assertThat(aCommandInServer.getRestricted()).isFalse(); + } + + public List commandsInServer() { + return Collections.singletonList(ACommandInAServer + .builder() + .build()); + } + + public ACommandInAServer aCommandInAServer() { + return ACommandInAServer + .builder() + .build(); + } + + private ACommand aCommand() { + return ACommand + .builder() + .build(); + } + + private AServer aServer() { + return AServer + .builder() + .build(); + } +} diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBeanTest.java new file mode 100644 index 000000000..690db3227 --- /dev/null +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBeanTest.java @@ -0,0 +1,116 @@ +package dev.sheldan.abstracto.core.command.service.management; + +import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException; +import dev.sheldan.abstracto.core.command.model.database.ACommand; +import dev.sheldan.abstracto.core.command.model.database.AModule; +import dev.sheldan.abstracto.core.command.repository.CommandRepository; +import dev.sheldan.abstracto.core.models.database.AFeature; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class CommandManagementServiceBeanTest { + + @InjectMocks + private CommandManagementServiceBean unitToTest; + + @Mock + private CommandRepository repository; + + private static final String COMMAND_NAME = "NAME"; + private static final String COMMAND_NAME_LOWER = COMMAND_NAME.toLowerCase(); + + @Test + public void getAllCommands() { + List commands = commands(); + when(repository.findAll()).thenReturn(commands); + + assertThat(unitToTest.getAllCommands()).isEqualTo(commands); + } + + @Test + public void doesCommandExist() { + when(repository.existsByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(true); + assertThat(unitToTest.doesCommandExist(COMMAND_NAME)).isTrue(); + } + + @Test + public void findCommandByName() { + ACommand aCommand = aCommand(); + when(repository.findByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(Optional.of(aCommand)); + ACommand commandByName = unitToTest.findCommandByName(COMMAND_NAME); + assertThat(commandByName).isEqualTo(aCommand); + } + + @Test + public void findCommandByNameNotExists() { + when(repository.findByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(Optional.empty()); + assertThatThrownBy(() -> { + unitToTest.findCommandByName(COMMAND_NAME); + }).isInstanceOf(CommandNotFoundException.class); + } + + @Test + public void findCommandByNameOptional() { + ACommand aCommand = aCommand(); + Optional optionalACommand = Optional.of(aCommand); + when(repository.findByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(optionalACommand); + Optional commandByName = unitToTest.findCommandByNameOptional(COMMAND_NAME); + assertThat(commandByName).isEqualTo(optionalACommand); + } + + @Test + public void findCommandByNameOptionalEmpty() { + when(repository.findByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(Optional.empty()); + Optional commandByName = unitToTest.findCommandByNameOptional(COMMAND_NAME); + assertThat(commandByName).isEmpty(); + } + + @Test + public void createCommandWithObj() { + AModule aModule = aModule(); + AFeature aFeature = aFeature(); + ArgumentCaptor aCommandArgumentCaptor = ArgumentCaptor.forClass(ACommand.class); + unitToTest.createCommand(COMMAND_NAME, aModule, aFeature); + verify(repository).save(aCommandArgumentCaptor.capture()); + ACommand aCommand = aCommandArgumentCaptor.getValue(); + assertThat(aCommand.getModule()).isEqualTo(aModule); + assertThat(aCommand.getFeature()).isEqualTo(aFeature); + assertThat(aCommand.getName()).isEqualTo(COMMAND_NAME_LOWER); + } + + private AModule aModule() { + return AModule + .builder() + .build(); + } + + private AFeature aFeature() { + return AFeature + .builder() + .build(); + } + + private List commands() { + return Collections.singletonList(aCommand()); + } + + private ACommand aCommand() { + return ACommand + .builder() + .build(); + } +} diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBeanTest.java new file mode 100644 index 000000000..e8a3ada2e --- /dev/null +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CoolDownChannelGroupManagementServiceBeanTest.java @@ -0,0 +1,75 @@ +package dev.sheldan.abstracto.core.command.service.management; + +import dev.sheldan.abstracto.core.command.model.database.CoolDownChannelGroup; +import dev.sheldan.abstracto.core.command.repository.CoolDownChannelGroupRepository; +import dev.sheldan.abstracto.core.models.database.AChannelGroup; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class CoolDownChannelGroupManagementServiceBeanTest { + + @InjectMocks + private CoolDownChannelGroupManagementServiceBean unitToTest; + + @Mock + private CoolDownChannelGroupRepository repository; + + private static final Long CHANNEL_GROUP_ID = 1L; + + @Test + public void createCoolDownChannelGroup() { + AChannelGroup aChannelGroup = aChannelGroup(); + + ArgumentCaptor coolDownChannelGroupArgumentCaptor = ArgumentCaptor.forClass(CoolDownChannelGroup.class); + + unitToTest.createCoolDownChannelGroup(aChannelGroup); + + verify(repository).save(coolDownChannelGroupArgumentCaptor.capture()); + + CoolDownChannelGroup coolDownChannelGroupArgumentCaptorValue = coolDownChannelGroupArgumentCaptor.getValue(); + assertThat(coolDownChannelGroupArgumentCaptorValue.getChannelGroup()).isEqualTo(aChannelGroup); + assertThat(coolDownChannelGroupArgumentCaptorValue.getMemberCoolDown()).isEqualTo(0L); + assertThat(coolDownChannelGroupArgumentCaptorValue.getChannelCoolDown()).isEqualTo(0L); + assertThat(coolDownChannelGroupArgumentCaptorValue.getId()).isEqualTo(CHANNEL_GROUP_ID); + } + + @Test + public void findByChannelGroupId() { + CoolDownChannelGroup aCoolDownChannelGroup = aCooldownChannelGroup(); + when(repository.getReferenceById(CHANNEL_GROUP_ID)).thenReturn(aCoolDownChannelGroup); + + assertThat(unitToTest.findByChannelGroupId(CHANNEL_GROUP_ID)).isEqualTo(aCoolDownChannelGroup); + } + + @Test + public void deleteCoolDownChannelGroup() { + AChannelGroup aChannelGroup = aChannelGroup(); + + unitToTest.deleteCoolDownChannelGroup(aChannelGroup); + + verify(repository).deleteById(CHANNEL_GROUP_ID); + } + + private CoolDownChannelGroup aCooldownChannelGroup() { + return CoolDownChannelGroup + .builder() + .build(); + } + + private AChannelGroup aChannelGroup() { + return AChannelGroup + .builder() + .id(CHANNEL_GROUP_ID) + .build(); + } + +} diff --git a/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/ModuleManagementServiceBeanTest.java b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/ModuleManagementServiceBeanTest.java new file mode 100644 index 000000000..78d2988b9 --- /dev/null +++ b/abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/ModuleManagementServiceBeanTest.java @@ -0,0 +1,92 @@ +package dev.sheldan.abstracto.core.command.service.management; + +import dev.sheldan.abstracto.core.command.model.database.AModule; +import dev.sheldan.abstracto.core.command.repository.ModuleRepository; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ModuleManagementServiceBeanTest { + + @InjectMocks + private ModuleManagementServiceBean unitToTest; + + @Mock + private ModuleRepository repository; + + private static final String MODULE_NAME = "module"; + + @Test + public void doesModuleExist() { + AModule aModule = aModule(); + when(repository.findByName(MODULE_NAME)).thenReturn(aModule); + + assertThat(unitToTest.doesModuleExist(MODULE_NAME)).isTrue(); + } + + @Test + public void doesModuleNotExist() { + when(repository.findByName(MODULE_NAME)).thenReturn(null); + + assertThat(unitToTest.doesModuleExist(MODULE_NAME)).isFalse(); + } + + @Test + public void findModuleByName() { + AModule aModule = aModule(); + when(repository.findByName(MODULE_NAME)).thenReturn(aModule); + + assertThat(unitToTest.findModuleByName(MODULE_NAME)).isEqualTo(aModule); + } + + @Test + public void createModule() { + ArgumentCaptor aModuleArgumentCaptor = ArgumentCaptor.forClass(AModule.class); + + unitToTest.createModule(MODULE_NAME); + + verify(repository).save(aModuleArgumentCaptor.capture()); + AModule aModule = aModuleArgumentCaptor.getValue(); + assertThat(aModule.getName()).endsWith(MODULE_NAME); + } + + @Test + public void getOrCreate() { + AModule aModule = aModule(); + when(repository.findByName(MODULE_NAME)).thenReturn(aModule); + + AModule createdModule = unitToTest.getOrCreate(MODULE_NAME); + + assertThat(createdModule).isEqualTo(aModule); + } + + @Test + public void getOrCreateNotExisting() { + AModule aModule = aModule(); + when(repository.findByName(MODULE_NAME)).thenReturn(null); + ArgumentCaptor aModuleArgumentCaptor = ArgumentCaptor.forClass(AModule.class); + when(repository.save(any())).thenReturn(aModule); + + AModule returnedModule = unitToTest.getOrCreate(MODULE_NAME); + + verify(repository).save(aModuleArgumentCaptor.capture()); + AModule createdModule = aModuleArgumentCaptor.getValue(); + assertThat(createdModule.getName()).endsWith(MODULE_NAME); + assertThat(returnedModule).isEqualTo(aModule); + } + + private AModule aModule() { + return AModule + .builder() + .build(); + } +} diff --git a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementService.java b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementService.java index de33817f3..eaa66e7e5 100644 --- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementService.java +++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementService.java @@ -9,7 +9,6 @@ import java.util.List; public interface CommandInServerManagementService { ACommandInAServer createCommandInServer(ACommand command, AServer server); - ACommandInAServer createCommandInServer(ACommand command, AServer server, Long commandId); boolean doesCommandExistInServer(ACommand command, AServer server); ACommandInAServer getCommandForServer(ACommand command, AServer server); void setCooldownForCommandInServer(ACommand command, AServer server, Duration duration); diff --git a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementService.java b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementService.java index 6bbc0482d..95ba8d6a8 100644 --- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementService.java +++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementService.java @@ -8,7 +8,6 @@ import java.util.List; import java.util.Optional; public interface CommandManagementService { - ACommand createCommand(String name, String moduleName, String featureName); ACommand createCommand(String name, AModule moduleName, AFeature feature); Optional findCommandByNameOptional(String name); ACommand findCommandByName(String name);