[AB-70] adding concept of command parameter validators and applied them at various places, this has the intention for commands to fail early

removing duplicated command for assignable role places

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/Parameter.java

@@ -4,8 +4,14 @@ import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
 
-@Getter @Setter @Builder
-public class Parameter {
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class Parameter implements Serializable {
     private String name;
     private Class type;
     private String description;
@@ -16,4 +22,6 @@ public class Parameter {
     private Integer maxLength;
     @Builder.Default
     private Boolean templated = false;
+    @Builder.Default
+    private List<ParameterValidator> validators = new ArrayList<>();
 }

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/ParameterValidator.java

@@ -0,0 +1,11 @@
+package dev.sheldan.abstracto.core.command.config;
+
+import dev.sheldan.abstracto.core.command.config.validator.ValidatorParam;
+
+import java.util.List;
+
+public interface ParameterValidator {
+    boolean validate(Object value);
+    List<ValidatorParam> getParameters();
+    String getTemplateName();
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/validator/MaxIntegerValueValidator.java

@@ -0,0 +1,45 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import dev.sheldan.abstracto.core.command.config.ParameterValidator;
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class MaxIntegerValueValidator implements ParameterValidator {
+
+    private Long maxValue;
+
+    @Override
+    public boolean validate(Object value) {
+        if(value == null) {
+            throw new IllegalArgumentException("Object to validate must not be null");
+        }
+        if(!(value instanceof Long)) {
+            throw new ValidatorConfigException("Incorrect value passed to max value validator.");
+        }
+        SingleNumberValidatorParam param = (SingleNumberValidatorParam) getParameters().get(0);
+        Long longValue = (Long) value;
+        return longValue <= param.getNumber();
+    }
+
+    @Override
+    public List<ValidatorParam> getParameters() {
+        SingleNumberValidatorParam param = SingleNumberValidatorParam
+                .builder()
+                .number(maxValue)
+                .build();
+        return Arrays.asList(param);
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "command_parameter_validation_value_too_large";
+    }
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/validator/MaxStringLengthValidator.java

@@ -0,0 +1,54 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import dev.sheldan.abstracto.core.command.config.ParameterValidator;
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class MaxStringLengthValidator implements ParameterValidator {
+
+    private Long maxLength;
+
+    @Override
+    public boolean validate(Object value) {
+        if(value == null) {
+            throw new IllegalArgumentException("Object to validate must not be null");
+        }
+        if(!(value instanceof String)) {
+            throw new ValidatorConfigException("Incorrect value passed to max string length validator.");
+        }
+        SingleNumberValidatorParam param = (SingleNumberValidatorParam) getParameters().get(0);
+        String stringValue = (String) value;
+        return stringValue.length() <= param.getNumber();
+    }
+
+    @Override
+    public List<ValidatorParam> getParameters() {
+        SingleNumberValidatorParam param = SingleNumberValidatorParam
+                .builder()
+                .number(maxLength)
+                .build();
+        return Arrays.asList(param);
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "command_parameter_validation_string_too_long";
+    }
+
+    public static MaxStringLengthValidator max(Long number) {
+        return  MaxStringLengthValidator
+                .builder()
+                .maxLength(number)
+                .build();
+    }
+
+
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/validator/MinIntegerValueValidator.java

@@ -0,0 +1,53 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import dev.sheldan.abstracto.core.command.config.ParameterValidator;
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class MinIntegerValueValidator implements ParameterValidator {
+
+    private Long minValue;
+
+    @Override
+    public boolean validate(Object value) {
+        if(value == null) {
+            throw new IllegalArgumentException("Object to validate must not be null");
+        }
+        if(!(value instanceof Long)) {
+            throw new ValidatorConfigException("Incorrect value passed to max value validator.");
+        }
+        SingleNumberValidatorParam param = (SingleNumberValidatorParam) getParameters().get(0);
+        Long longValue = (Long) value;
+        return longValue >= param.getNumber();
+    }
+
+    @Override
+    public List<ValidatorParam> getParameters() {
+        SingleNumberValidatorParam param = SingleNumberValidatorParam
+                .builder()
+                .number(minValue)
+                .build();
+        return Arrays.asList(param);
+    }
+
+    public static MinIntegerValueValidator min(Long number) {
+        return  MinIntegerValueValidator
+                .builder()
+                .minValue(number)
+                .build();
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "command_parameter_validation_value_too_small";
+    }
+
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/validator/MinStringLengthValidator.java

@@ -0,0 +1,45 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import dev.sheldan.abstracto.core.command.config.ParameterValidator;
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class MinStringLengthValidator implements ParameterValidator {
+
+    private Long minLength;
+
+    @Override
+    public boolean validate(Object value) {
+        if(value == null) {
+            throw new IllegalArgumentException("Object to validate must not be null");
+        }
+        if(!(value instanceof String)) {
+            throw new ValidatorConfigException("Incorrect value passed to min string length validator.");
+        }
+        SingleNumberValidatorParam param = (SingleNumberValidatorParam) getParameters().get(0);
+        String stringValue = (String) value;
+        return stringValue.length() >= param.getNumber();
+    }
+
+    @Override
+    public List<ValidatorParam> getParameters() {
+        SingleNumberValidatorParam param = SingleNumberValidatorParam
+                .builder()
+                .number(minLength)
+                .build();
+        return Arrays.asList(param);
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "command_parameter_validation_string_too_short";
+    }
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/validator/SingleNumberValidatorParam.java

@@ -0,0 +1,12 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class SingleNumberValidatorParam implements ValidatorParam {
+    private Long number;
+}

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/command/config/validator/ValidatorParam.java

@@ -0,0 +1,6 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import java.io.Serializable;
+
+public interface ValidatorParam extends Serializable {
+}

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

@@ -0,0 +1,37 @@
+package dev.sheldan.abstracto.core.command.exception;
+
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.config.validator.ValidatorParam;
+import dev.sheldan.abstracto.core.command.models.exception.CommandParameterValidationExceptionModel;
+import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
+import dev.sheldan.abstracto.templating.Templatable;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+public class CommandParameterValidationException extends AbstractoRunTimeException implements Templatable {
+
+    private final CommandParameterValidationExceptionModel model;
+
+    public CommandParameterValidationException(List<ValidatorParam> validatorParams, String template, Parameter parameter) {
+        this.model = CommandParameterValidationExceptionModel
+                .builder()
+                .validationTemplate(template)
+                .validatorParams(validatorParams)
+                .parameter(parameter)
+                .build();
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "command_parameter_validation_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return model;
+    }
+}

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

@@ -0,0 +1,9 @@
+package dev.sheldan.abstracto.core.command.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
+
+public class ValidatorConfigException extends AbstractoRunTimeException {
+    public ValidatorConfigException(String message) {
+        super(message);
+    }
+}

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

@@ -0,0 +1,19 @@
+package dev.sheldan.abstracto.core.command.models.exception;
+
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.config.validator.ValidatorParam;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class CommandParameterValidationExceptionModel implements Serializable {
+    private List<ValidatorParam> validatorParams;
+    private String validationTemplate;
+    private Parameter parameter;
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/command/config/validator/MaxIntegerValueValidatorTest.java

@@ -0,0 +1,45 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MaxIntegerValueValidatorTest {
+    @InjectMocks
+    private MaxIntegerValueValidator validator;
+
+    @Before
+    public void setup() {
+        validator.setMaxValue(4L);
+    }
+
+    @Test(expected = ValidatorConfigException.class)
+    public void incorrectArgument() {
+        validator.validate("");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void nullArgument() {
+        validator.validate(null);
+    }
+
+    @Test
+    public void littleEnoughValue() {
+        Assert.assertTrue(validator.validate(3L));
+    }
+
+    @Test
+    public void exactValue() {
+        Assert.assertTrue(validator.validate(4L));
+    }
+
+    @Test
+    public void tooLargeValue() {
+        Assert.assertFalse(validator.validate(5L));
+    }
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/command/config/validator/MaxStringLengthValidatorTest.java

@@ -0,0 +1,53 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MaxStringLengthValidatorTest {
+    @InjectMocks
+    private MaxStringLengthValidator validator;
+
+    @Before
+    public void setup() {
+        validator.setMaxLength(4L);
+    }
+
+    @Test(expected = ValidatorConfigException.class)
+    public void incorrectArgument() {
+        validator.validate(4L);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void nullArgument() {
+        validator.validate(null);
+    }
+
+    @Test
+    public void validateEmptyString() {
+        Assert.assertTrue(validator.validate(""));
+    }
+
+    @Test
+    public void validateShortString() {
+        Assert.assertTrue(validator.validate("t"));
+    }
+
+    @Test
+    public void validateExactString() {
+        Assert.assertTrue(validator.validate("text"));
+    }
+
+    @Test
+    public void validateTooLongString() {
+        Assert.assertFalse(validator.validate("text1"));
+    }
+
+
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/command/config/validator/MinIntegerValueValidatorTest.java

@@ -0,0 +1,45 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MinIntegerValueValidatorTest {
+    @InjectMocks
+    private MinIntegerValueValidator validator;
+
+    @Before
+    public void setup() {
+        validator.setMinValue(4L);
+    }
+
+    @Test(expected = ValidatorConfigException.class)
+    public void incorrectArgument() {
+        validator.validate("");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void nullArgument() {
+        validator.validate(null);
+    }
+
+    @Test
+    public void tooLittleValue() {
+        Assert.assertFalse(validator.validate(3L));
+    }
+
+    @Test
+    public void exactValue() {
+        Assert.assertTrue(validator.validate(4L));
+    }
+
+    @Test
+    public void largeEnoughValue() {
+        Assert.assertTrue(validator.validate(5L));
+    }
+}

abstracto-application/core/core-interface/src/test/java/dev/sheldan/abstracto/core/command/config/validator/MinStringLengthValidatorTest.java

@@ -0,0 +1,51 @@
+package dev.sheldan.abstracto.core.command.config.validator;
+
+
+import dev.sheldan.abstracto.core.command.exception.ValidatorConfigException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MinStringLengthValidatorTest {
+    @InjectMocks
+    private MinStringLengthValidator validator;
+
+    @Before
+    public void setup() {
+        validator.setMinLength(4L);
+    }
+
+    @Test(expected = ValidatorConfigException.class)
+    public void incorrectArgument() {
+        validator.validate(4L);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void nullArgument() {
+        validator.validate(null);
+    }
+
+    @Test
+    public void validateEmptyString() {
+        Assert.assertFalse(validator.validate(""));
+    }
+
+    @Test
+    public void validateShortString() {
+        Assert.assertFalse(validator.validate("t"));
+    }
+
+    @Test
+    public void validateExactString() {
+        Assert.assertTrue(validator.validate("text"));
+    }
+
+    @Test
+    public void validateLongEnoughString() {
+        Assert.assertTrue(validator.validate("text1"));
+    }
+}