[AB-xxx] adding tests for command management services

some code improvements

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<AChannelGroupCommand> 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<AChannelGroupCommand> groupCommandOptional = groupCommandRepository.findByCommandAndGroup(command, group);
-        if(!groupCommandOptional.isPresent()) {
+        if(groupCommandOptional.isEmpty()) {
             throw new CommandNotFoundInGroupException();
         }
         groupCommandOptional.ifPresent(channelGroupCommand -> groupCommandRepository.delete(channelGroupCommand));

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());
     }
 }

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

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

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());
     }
 }

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);
     }
 

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);
     }
 

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);
     }
 

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();
     }
 

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();
     }
 

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);
     }
 

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);
     }
 

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);
     }

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);
     }

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();
     }
 

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();
     }
 

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<Member> 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<Member> 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<Object> 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<Object> 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<Object> future = testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command);
+
         Member returnedMember = (Member) future.join();
         assertThat(future.isCompletedExceptionally()).isFalse();
         assertThat(returnedMember).isEqualTo(member);

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);
     }
 

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<AChannelGroupCommand> channelGroupCommands = channelGroupCommands();
+        ACommand aCommand = aCommand();
+        when(repository.findByCommand(aCommand)).thenReturn(channelGroupCommands);
+
+        assertThat(unitToTest.getAllGroupCommandsForCommand(aCommand)).isEqualTo(channelGroupCommands);
+    }
+
+    @Test
+    public void allGroupsForCommandAndGroups() {
+        List<AChannelGroup> channelGroups = getChannelGroups();
+        ACommand aCommand = aCommand();
+        List<AChannelGroupCommand> channelGroupCommands = channelGroupCommands();
+        when(repository.findByCommandAndGroupIn(aCommand, channelGroups)).thenReturn(channelGroupCommands);
+
+        assertThat(unitToTest.getAllGroupCommandsForCommandInGroups(aCommand, channelGroups)).isEqualTo(channelGroupCommands);
+    }
+
+    @Test
+    public void allGroupsForCommandsAndGroupsOfType() {
+        ACommand aCommand = aCommand();
+        List<AChannelGroupCommand> 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<AChannelGroupCommand> 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<AChannelGroupCommand> 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<AChannelGroupCommand> 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<AChannelGroupCommand> channelGroupCommands() {
+        return Collections.singletonList(AChannelGroupCommand
+                .builder()
+                .build());
+    }
+
+    private AChannelGroupCommand aChannelGroupCommand() {
+        return AChannelGroupCommand
+                .builder()
+                .build();
+    }
+
+    private List<AChannelGroup> getChannelGroups() {
+        return Collections.singletonList(AChannelGroup
+                .builder()
+                .build());
+    }
+
+    private AChannelGroup aChannelGroup() {
+        return AChannelGroup
+                .builder()
+                .build();
+    }
+}

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<CommandDisabledChannelGroup> 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();
+    }
+}

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<ACommandInServerAlias> 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<ACommandInServerAlias> 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<ACommandInServerAlias> commandOptional = testUnit.getCommandInServerAlias(server, ALIAS_NAME);
-        Assert.assertFalse(commandOptional.isPresent());
+
+        assertThat(commandOptional.isPresent()).isFalse();
     }
 
     @Test
@@ -80,23 +88,28 @@ public class CommandInServerAliasManagementServiceBeanTest {
         ArgumentCaptor<ACommandInServerAlias> 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<ACommandInServerAlias> 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);
     }
 }

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<Long> commandIds = Arrays.asList(COMMAND_ID);
+        List<ACommandInAServer> 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<ACommandInAServer> 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<ACommandInAServer> 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();
+    }
+}

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<ACommand> 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<ACommand> optionalACommand = Optional.of(aCommand);
+        when(repository.findByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(optionalACommand);
+        Optional<ACommand> commandByName = unitToTest.findCommandByNameOptional(COMMAND_NAME);
+        assertThat(commandByName).isEqualTo(optionalACommand);
+    }
+
+    @Test
+    public void findCommandByNameOptionalEmpty() {
+        when(repository.findByNameIgnoreCase(COMMAND_NAME_LOWER)).thenReturn(Optional.empty());
+        Optional<ACommand> commandByName = unitToTest.findCommandByNameOptional(COMMAND_NAME);
+        assertThat(commandByName).isEmpty();
+    }
+
+    @Test
+    public void createCommandWithObj() {
+        AModule aModule = aModule();
+        AFeature aFeature = aFeature();
+        ArgumentCaptor<ACommand> 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<ACommand> commands() {
+        return Collections.singletonList(aCommand());
+    }
+
+    private ACommand aCommand() {
+        return ACommand
+                .builder()
+                .build();
+    }
+}

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<CoolDownChannelGroup> 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();
+    }
+
+}

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<AModule> 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<AModule> 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();
+    }
+}

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);

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<ACommand> findCommandByNameOptional(String name);
     ACommand findCommandByName(String name);