[AB-78] adding new concept of feature modes, with splitting it up to new commands and default mode concept

refactoring command received handler to only load the entities in the same thread as the actual executed commands, so that user initiated context contains valid references from the same thread
updating documentation
fixing issue when the result of role calculation result in no experience role id

abstracto-application/core/core-interface/pom.xml

@@ -12,6 +12,22 @@
 
     <artifactId>core-interface</artifactId>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>test-jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
 
     <dependencies>
         <dependency>

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/condition/FeatureModeCondition.java

@@ -2,51 +2,33 @@ package dev.sheldan.abstracto.core.command.condition;
 
 import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.models.exception.IncorrectFeatureModeMessage;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
-import dev.sheldan.abstracto.core.models.database.AFeatureMode;
-import dev.sheldan.abstracto.core.service.FeatureConfigService;
-import dev.sheldan.abstracto.core.service.FeatureFlagService;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.exception.IncorrectFeatureModeException;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
-import dev.sheldan.abstracto.templating.service.TemplateService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 @Component
 public class FeatureModeCondition implements CommandCondition {
 
-    @Autowired
-    private TemplateService templateService;
-
-    @Autowired
-    private FeatureConfigService featureConfigService;
-
-    @Autowired
-    private FeatureFlagService featureFlagService;
-
     @Autowired
     private FeatureModeService modeService;
 
     @Override
     public ConditionResult shouldExecute(CommandContext context, Command command) {
-        String reason = "";
-        boolean featureModeFits = true;
         if(!command.getFeatureModeLimitations().isEmpty()){
             FeatureEnum feature = command.getFeature();
             if(feature != null) {
-                AFeatureMode featureMode = modeService.getFeatureMode(feature, context.getUserInitiatedContext().getServer());
-                featureModeFits = command.getFeatureModeLimitations().stream().anyMatch(featureMode1 -> featureMode1.getKey().equalsIgnoreCase(featureMode.getMode()));
-                if(!featureModeFits) {
-                    IncorrectFeatureModeMessage featureDisabledMessage = IncorrectFeatureModeMessage
-                            .builder()
-                            .featureConfig(featureConfigService.getFeatureDisplayForFeature(feature))
-                            .command(command)
-                            .build();
-                    reason = templateService.renderTemplate("feature_mode_not_correct_message", featureDisabledMessage);
+                for (FeatureMode featureModeLimitation : command.getFeatureModeLimitations()) {
+                    if(modeService.featureModeActive(feature, context.getUserInitiatedContext().getServer(), featureModeLimitation)) {
+                        return ConditionResult.builder().result(true).build();
+                    }
                 }
+                throw new IncorrectFeatureModeException(command, feature, command.getFeatureModeLimitations());
             }
         }
 
-        return ConditionResult.builder().reason(reason).result(featureModeFits).build();
+        return ConditionResult.builder().result(true).build();
     }
 }

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/exception/IncorrectFeatureModeException.java

@@ -0,0 +1,30 @@
+package dev.sheldan.abstracto.core.exception;
+
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.models.exception.IncorrectFeatureModeExceptionModel;
+import dev.sheldan.abstracto.templating.Templatable;
+
+import java.util.List;
+
+public class IncorrectFeatureModeException extends AbstractoRunTimeException implements Templatable {
+
+    private final IncorrectFeatureModeExceptionModel model;
+
+    public IncorrectFeatureModeException(Command command, FeatureEnum featureEnum, List<FeatureMode> requiredModes) {
+        super("Incorrect feature mode for the command.");
+        this.model = IncorrectFeatureModeExceptionModel.builder().command(command).featureEnum(featureEnum).requiredModes(requiredModes).build();
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "incorrect_feature_mode_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return model;
+    }
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/database/AFeatureFlag.java

@@ -6,6 +6,7 @@ import org.hibernate.annotations.CacheConcurrencyStrategy;
 import javax.persistence.*;
 import java.io.Serializable;
 import java.time.Instant;
+import java.util.List;
 import java.util.Objects;
 
 @Entity
@@ -35,6 +36,12 @@ public class AFeatureFlag implements Serializable {
     @JoinColumn(name = "feature_id", nullable = false)
     private AFeature feature;
 
+    @Getter
+    @Setter
+    @OneToMany(fetch = FetchType.LAZY, mappedBy = "featureFlag")
+    @org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+    private List<AFeatureMode> modes;
+
     @Getter
     @Setter
     private boolean enabled;

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/database/AFeatureMode.java

@@ -23,14 +23,26 @@ public class AFeatureMode implements Serializable {
 
     @Getter
     @Setter
-    @OneToOne
+    @ManyToOne
     @JoinColumn(name = "feature_flag_id", nullable = false)
     private AFeatureFlag featureFlag;
 
-    @Column
-    @Setter
     @Getter
-    private String mode;
+    @Setter
+    @ManyToOne
+    @JoinColumn(name = "feature_mode_id", nullable = false)
+    private DefaultFeatureMode featureMode;
+
+    @Getter
+    @Setter
+    @OneToOne
+    @JoinColumn(name = "server_id", nullable = false)
+    private AServer server;
+
+    @Column
+    @Getter
+    @Setter
+    private Boolean enabled;
 
     @Column(name = "created")
     private Instant created;

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/database/DefaultFeatureMode.java

@@ -0,0 +1,62 @@
+package dev.sheldan.abstracto.core.models.database;
+
+import lombok.*;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.time.Instant;
+import java.util.List;
+
+@Entity
+@Table(name="default_feature_mode")
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Cacheable
+@EqualsAndHashCode
+@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class DefaultFeatureMode implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Getter
+    @Column(name = "id")
+    public Long id;
+
+    @Getter
+    @Setter
+    @OneToOne
+    @JoinColumn(name = "feature_id", nullable = false)
+    private AFeature feature;
+
+    @Getter
+    @Setter
+    @OneToMany(fetch = FetchType.LAZY, mappedBy = "featureMode")
+    @org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+    private List<AFeatureMode> modes;
+
+    @Getter
+    @Setter
+    private boolean enabled;
+
+    @Getter
+    @Setter
+    private String mode;
+
+    @Column(name = "created")
+    private Instant created;
+
+    @PrePersist
+    private void onInsert() {
+        this.created = Instant.now();
+    }
+
+    @Column(name = "updated")
+    private Instant updateTimestamp;
+
+    @PreUpdate
+    private void onUpdate() {
+        this.updateTimestamp = Instant.now();
+    }
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/exception/IncorrectFeatureModeExceptionModel.java

@@ -0,0 +1,20 @@
+package dev.sheldan.abstracto.core.models.exception;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class IncorrectFeatureModeExceptionModel implements Serializable {
+    private List<FeatureMode> requiredModes;
+    private Command command;
+    private FeatureEnum featureEnum;
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/template/commands/FeatureModeDisplay.java

@@ -0,0 +1,16 @@
+package dev.sheldan.abstracto.core.models.template.commands;
+
+import dev.sheldan.abstracto.core.config.FeatureConfig;
+import dev.sheldan.abstracto.core.models.database.AFeatureMode;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class FeatureModeDisplay {
+    private AFeatureMode featureMode;
+    private FeatureConfig featureConfig;
+    private Boolean isDefaultValue;
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/template/commands/FeatureModesModel.java

@@ -0,0 +1,15 @@
+package dev.sheldan.abstracto.core.models.template.commands;
+
+import dev.sheldan.abstracto.core.models.context.UserInitiatedServerContext;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@Getter
+@Setter
+@SuperBuilder
+public class FeatureModesModel extends UserInitiatedServerContext {
+    private List<FeatureModeDisplay> featureModes;
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/FeatureConfigService.java

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
 import dev.sheldan.abstracto.core.models.FeatureValidationResult;
+import dev.sheldan.abstracto.core.models.database.AFeature;
 import dev.sheldan.abstracto.core.models.database.AServer;
 
 import java.util.List;
@@ -22,5 +23,6 @@ public interface FeatureConfigService {
     PostTargetEnum getPostTargetEnumByKey(String key);
     FeatureValidationResult validateFeatureSetup(FeatureConfig featureConfig, AServer server);
     FeatureMode getFeatureModeByKey(FeatureConfig featureConfig, String key);
+    FeatureConfig getFeatureConfigForFeature(AFeature feature);
     boolean isModeValid(String featureName, String modeName);
 }

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/FeatureModeService.java

@@ -3,27 +3,19 @@ package dev.sheldan.abstracto.core.service;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.models.database.AFeature;
-import dev.sheldan.abstracto.core.models.database.AFeatureFlag;
-import dev.sheldan.abstracto.core.models.database.AFeatureMode;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.template.commands.FeatureModeDisplay;
+
+import java.util.List;
 
 public interface FeatureModeService {
-    AFeatureMode setModeForFeatureTo(String key, AServer server, String newMode);
-    AFeatureMode setModeForFeatureTo(AFeatureFlag flag, String newMode);
-    AFeatureMode setModeForFeatureTo(FeatureEnum featureEnum, AServer server, String newMode);
-    AFeatureMode setModeForFeatureTo(AFeature featureEnum, AServer server, String newMode);
-    AFeatureMode setModeForFeatureTo(FeatureEnum featureEnum, AServer server, FeatureMode mode);
-    AFeatureMode setModeForFeatureTo(AFeature feature, AServer server, FeatureMode mode);
-    AFeatureMode setModeForFeatureTo(AFeatureFlag featureFlag, FeatureMode mode);
 
-    AFeatureMode createMode(String key, AServer server, String newMode);
-    AFeatureMode createMode(AFeatureFlag flag, String newMode);
-    AFeatureMode createMode(FeatureEnum featureEnum, AServer server, String newMode);
-    AFeatureMode createMode(AFeature featureEnum, AServer server, String newMode);
-    AFeatureMode createMode(FeatureEnum featureEnum, AServer server, FeatureMode mode);
-    AFeatureMode createMode(AFeature feature, AServer server, FeatureMode mode);
-    AFeatureMode createMode(AFeatureFlag featureFlag, FeatureMode mode);
-
-    AFeatureMode getFeatureMode(FeatureEnum featureEnum, AServer server);
-    AFeatureMode getFeatureMode(AFeature feature, AServer server);
+    void enableFeatureModeForFeature(FeatureEnum featureEnum, AServer server, FeatureMode mode);
+    void setFutureModeForFuture(FeatureEnum featureEnum, AServer server, FeatureMode mode, Boolean newValue);
+    void disableFeatureModeForFeature(FeatureEnum featureEnum, AServer server, FeatureMode mode);
+    boolean featureModeActive(FeatureEnum featureEnum, AServer server, FeatureMode mode);
+    FeatureMode getFeatureModeForKey(String key);
+    List<FeatureMode> getAllAvailableFeatureModes();
+    List<FeatureModeDisplay> getEffectiveFeatureModes(AServer server);
+    List<FeatureModeDisplay> getEffectiveFeatureModes(AServer server, AFeature feature);
 }

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/management/DefaultFeatureModeManagement.java

@@ -0,0 +1,14 @@
+package dev.sheldan.abstracto.core.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AFeature;
+import dev.sheldan.abstracto.core.models.database.DefaultFeatureMode;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface DefaultFeatureModeManagement {
+    List<DefaultFeatureMode> getFeatureModesForFeature(AFeature feature);
+    List<DefaultFeatureMode> getAll();
+    Optional<DefaultFeatureMode> getFeatureModeOptional(AFeature feature, String mode);
+    DefaultFeatureMode getFeatureMode(AFeature feature, String mode);
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/management/FeatureFlagManagementService.java

@@ -10,6 +10,7 @@ public interface FeatureFlagManagementService {
     AFeatureFlag createFeatureFlag(AFeature feature, Long serverId, Boolean newValue);
     AFeatureFlag createFeatureFlag(AFeature feature, AServer server, Boolean newValue);
     AFeatureFlag getFeatureFlag(AFeature key, Long serverId);
+    boolean featureFlagExists(AFeature feature, AServer server);
     AFeatureFlag getFeatureFlag(AFeature key, AServer server);
     List<AFeatureFlag> getFeatureFlagsOfServer(AServer server);
     AFeatureFlag setFeatureFlagValue(AFeature feature, Long serverId, Boolean newValue);

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/management/FeatureModeManagementService.java

@@ -6,9 +6,18 @@ import dev.sheldan.abstracto.core.models.database.AFeatureFlag;
 import dev.sheldan.abstracto.core.models.database.AFeatureMode;
 import dev.sheldan.abstracto.core.models.database.AServer;
 
+import java.util.List;
+import java.util.Optional;
+
 public interface FeatureModeManagementService {
-    AFeatureMode createMode(AFeatureFlag featureFlag, FeatureMode mode);
-    AFeatureMode getModeForFeature(AFeatureFlag featureFlag);
-    boolean featureModeSet(AFeature aFeature, AServer server);
-    AFeatureMode setModeForFeature(AFeatureFlag featureFlag, FeatureMode featureMode);
+    AFeatureMode createMode(AFeatureFlag featureFlag, FeatureMode mode, boolean enabled);
+    AFeatureMode createMode(AFeatureFlag featureFlag, String mode, boolean enabled);
+
+    boolean isFeatureModeActive(AFeature aFeature, AServer server, FeatureMode mode);
+    boolean doesFeatureModeExist(AFeature aFeature, AServer server, FeatureMode mode);
+    boolean doesFeatureModeExist(AFeature aFeature, AServer server, String modeKey);
+    Optional<AFeatureMode> getFeatureMode(AFeature aFeature, AServer server, FeatureMode mode);
+    Optional<AFeatureMode> getFeatureMode(AFeature aFeature, AServer server, String modeKey);
+    List<AFeatureMode> getFeatureModesOfServer(AServer server);
+    List<AFeatureMode> getFeatureModesOfFeatureInServer(AServer server, AFeature aFeature);
 }

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/command/condition/FeatureModeConditionTest.java

@@ -0,0 +1,75 @@
+package dev.sheldan.abstracto.core.command.condition;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.exception.IncorrectFeatureModeException;
+import dev.sheldan.abstracto.core.models.context.UserInitiatedServerContext;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class FeatureModeConditionTest {
+
+    @InjectMocks
+    private FeatureModeCondition testUnit;
+
+    @Mock
+    private FeatureModeService modeService;
+
+    @Mock
+    private Command command;
+
+    @Mock
+    private CommandContext commandContext;
+
+    @Mock
+    private FeatureMode featureMode;
+
+    @Mock
+    private FeatureEnum featureEnum;
+
+    @Mock
+    private AServer server;
+
+    @Mock
+    private UserInitiatedServerContext userInitiatedServerContext;
+
+    @Test
+    public void testNoLimitations() {
+        when(command.getFeatureModeLimitations()).thenReturn(new ArrayList<>());
+        CommandTestUtilities.checkSuccessfulCondition(testUnit.shouldExecute(commandContext, command));
+    }
+
+    @Test
+    public void testMetLimitations() {
+        when(commandContext.getUserInitiatedContext()).thenReturn(userInitiatedServerContext);
+        when(userInitiatedServerContext.getServer()).thenReturn(server);
+        when(command.getFeature()).thenReturn(featureEnum);
+        when(modeService.featureModeActive(featureEnum, server, featureMode)).thenReturn(true);
+        when(command.getFeatureModeLimitations()).thenReturn(Arrays.asList(featureMode));
+        CommandTestUtilities.checkSuccessfulCondition(testUnit.shouldExecute(commandContext, command));
+    }
+
+    @Test(expected = IncorrectFeatureModeException.class)
+    public void testLimitedCommand() {
+        when(commandContext.getUserInitiatedContext()).thenReturn(userInitiatedServerContext);
+        when(userInitiatedServerContext.getServer()).thenReturn(server);
+        when(command.getFeature()).thenReturn(featureEnum);
+        when(modeService.featureModeActive(featureEnum, server, featureMode)).thenReturn(false);
+        when(command.getFeatureModeLimitations()).thenReturn(Arrays.asList(featureMode));
+        testUnit.shouldExecute(commandContext, command);
+    }
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/test/MockUtils.java

@@ -0,0 +1,33 @@
+package dev.sheldan.abstracto.core.test;
+
+import dev.sheldan.abstracto.core.models.database.*;
+
+public class MockUtils {
+
+    private MockUtils() {
+
+    }
+
+    public static AUserInAServer getUserObject(Long id, AServer server) {
+        AUser user = AUser.builder().id(id).build();
+        AUserInAServer createdUser = AUserInAServer.builder().userReference(user).serverReference(server).userInServerId(id).build();
+        server.getUsers().add(createdUser);
+        return createdUser;
+    }
+
+    public static AServer getServer(Long id){
+        return AServer.builder().id(id).build();
+    }
+
+    public static AServer getServer() {
+        return getServer(2L);
+    }
+
+    public static AChannel getTextChannel(AServer server, Long id) {
+        return AChannel.builder().id(id).server(server).deleted(false).type(AChannelType.TEXT).build();
+    }
+
+    public static ARole getRole(Long id, AServer server) {
+        return ARole.builder().server(server).id(id).build();
+    }
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/test/command/CommandConfigValidator.java

@@ -0,0 +1,44 @@
+package dev.sheldan.abstracto.core.test.command;
+
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import org.junit.Assert;
+
+public class CommandConfigValidator {
+
+    private CommandConfigValidator() {
+
+    }
+
+    public static void validateCommandConfiguration(CommandConfiguration toValidate) {
+        Assert.assertNotNull(toValidate.getModule());
+        Assert.assertNotNull(toValidate.getName());
+        if(toValidate.isTemplated()) {
+            Assert.assertNull(toValidate.getDescription());
+        } else {
+            Assert.assertNotNull(toValidate.getDescription());
+        }
+        toValidate.getParameters().forEach(parameter -> {
+            Assert.assertNotNull(parameter.getName());
+            Assert.assertNotNull(parameter.getType());
+            if(parameter.getTemplated()) {
+                Assert.assertNull(parameter.getDescription());
+            } else {
+                Assert.assertNotNull(parameter.getDescription());
+            }
+        });
+        HelpInfo helpInfo = toValidate.getHelp();
+        Assert.assertNotNull(helpInfo);
+        if(helpInfo.isTemplated()) {
+            Assert.assertNull(helpInfo.getLongHelp());
+            Assert.assertNull(helpInfo.getExample());
+        } else {
+            Assert.assertNotNull(helpInfo.getLongHelp());
+            if(helpInfo.isHasExample()) {
+                Assert.assertNotNull(helpInfo.getExample());
+            } else {
+                Assert.assertNull(helpInfo.getExample());
+            }
+        }
+    }
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/test/command/CommandTestUtilities.java

@@ -0,0 +1,116 @@
+package dev.sheldan.abstracto.core.test.command;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.condition.ConditionResult;
+import dev.sheldan.abstracto.core.command.config.Parameters;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ResultState;
+import dev.sheldan.abstracto.core.models.context.UserInitiatedServerContext;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.test.MockUtils;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.TextChannel;
+import org.junit.Assert;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class CommandTestUtilities {
+
+    private CommandTestUtilities() {
+
+    }
+
+    public static void checkSuccessfulCondition(ConditionResult result) {
+        Assert.assertTrue(result.isResult());
+    }
+
+    public static void executeNoParametersTest(Command com) {
+        CommandContext context = CommandTestUtilities.getNoParameters();
+        com.execute(context);
+    }
+
+    public static void executeNoParametersTestAsync(Command com) {
+        CommandContext context = CommandTestUtilities.getNoParameters();
+        com.executeAsync(context);
+    }
+
+    public static void executeWrongParametersTest(Command com) {
+        executeWrongParametersTest(com, new ArrayList<>());
+    }
+
+    public static void executeWrongParametersTest(Command com, Object value) {
+        CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(value));
+        com.execute(context);
+    }
+
+    public static void executeWrongParametersTestAsync(Command com) {
+        executeWrongParametersTestAsync(com, new ArrayList<>());
+    }
+
+    public static void executeWrongParametersTestAsync(Command com, Object value) {
+        CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(value));
+        com.executeAsync(context);
+    }
+
+    public static CommandContext getNoParameters() {
+        AServer server = MockUtils.getServer();
+        AUserInAServer author = MockUtils.getUserObject(3L, server);
+        CommandContext context = CommandContext
+                .builder()
+                .build();
+        Guild guild = Mockito.mock(Guild.class);
+        context.setGuild(guild);
+        Member member = Mockito.mock(Member.class);
+        context.setAuthor(member);
+        long channelId = 4L;
+        TextChannel mockedTextChannel = Mockito.mock(TextChannel.class);
+        UserInitiatedServerContext userInitiatedContext = UserInitiatedServerContext
+                .builder()
+                .server(server)
+                .guild(guild)
+                .aUserInAServer(author)
+                .member(member)
+                .user(author.getUserReference())
+                .channel(MockUtils.getTextChannel(server, channelId))
+                .messageChannel(mockedTextChannel)
+                .build();
+        context.setUserInitiatedContext(userInitiatedContext);
+        context.setChannel(mockedTextChannel);
+        context.setParameters(Parameters.builder().parameters(new ArrayList<>()).build());
+        context.setMessage(Mockito.mock(Message.class));
+        return context;
+    }
+
+    public static CommandContext getWithParameters(List<Object> parameters) {
+        CommandContext context = getNoParameters();
+        context.getParameters().getParameters().addAll(parameters);
+        return context;
+    }
+
+    public static CommandContext enhanceWithParameters(CommandContext context, List<Object> parameters) {
+        context.getParameters().getParameters().addAll(parameters);
+        return context;
+    }
+
+    public static void checkSuccessfulCompletion(CommandResult result){
+        Assert.assertEquals(ResultState.SUCCESSFUL, result.getResult());
+    }
+
+    public static void checkSuccessfulCompletionAsync(CompletableFuture<CommandResult> result){
+        Assert.assertEquals(ResultState.SUCCESSFUL, result.join().getResult());
+    }
+
+    public static List<CompletableFuture<Message>> messageFutureList() {
+        return Arrays.asList(CompletableFuture.completedFuture(null));
+    }
+
+
+}