From bce648dc5150b7988ac2ee1a2b91b8fc65c942b6 Mon Sep 17 00:00:00 2001 From: ZhouXY108 Date: Tue, 20 May 2025 17:41:23 +0800 Subject: [PATCH] =?UTF-8?q?test:=20=E5=AE=8C=E5=96=84=E5=8D=95=E5=85=83?= =?UTF-8?q?=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../validator/StringPropertyValidator.java | 30 +- .../ObjectPropertyValidatorTests.java | 312 +++++++++++- .../StringPropertyValidatorTests.java | 468 ++++++++++++++++-- 3 files changed, 748 insertions(+), 62 deletions(-) diff --git a/plusone-validator/src/main/java/xyz/zhouxy/plusone/validator/StringPropertyValidator.java b/plusone-validator/src/main/java/xyz/zhouxy/plusone/validator/StringPropertyValidator.java index a70550e..070ca09 100644 --- a/plusone-validator/src/main/java/xyz/zhouxy/plusone/validator/StringPropertyValidator.java +++ b/plusone-validator/src/main/java/xyz/zhouxy/plusone/validator/StringPropertyValidator.java @@ -22,8 +22,6 @@ import java.util.function.Function; import java.util.function.Supplier; import java.util.regex.Pattern; -import com.google.common.base.Strings; - import xyz.zhouxy.plusone.commons.constant.PatternConsts; import xyz.zhouxy.plusone.commons.util.AssertTools; import xyz.zhouxy.plusone.commons.util.RegexTools; @@ -158,7 +156,7 @@ public class StringPropertyValidator extends BaseComparablePropertyValidato // ================================ public StringPropertyValidator notBlank() { - return notBlank("This String argument must have text; it must not be null, empty, or blank"); + return notBlank("The value must have text; it must not be null, empty, or blank."); } public StringPropertyValidator notBlank(String errMsg) { @@ -209,6 +207,10 @@ public class StringPropertyValidator extends BaseComparablePropertyValidato // #region - notEmpty // ================================ + public StringPropertyValidator notEmpty() { + return notEmpty("The value must not be empty."); + } + public StringPropertyValidator notEmpty(String errMsg) { return notEmpty(convertExceptionCreator(errMsg)); } @@ -227,28 +229,6 @@ public class StringPropertyValidator extends BaseComparablePropertyValidato // #endregion - notEmpty // ================================ - // ================================ - // #region - isNullOrEmpty - // ================================ - - public StringPropertyValidator isNullOrEmpty(String errMsg) { - return isNullOrEmpty(convertExceptionCreator(errMsg)); - } - - public StringPropertyValidator isNullOrEmpty(Supplier exceptionCreator) { - return isNullOrEmpty(convertExceptionCreator(exceptionCreator)); - } - - public StringPropertyValidator isNullOrEmpty( - Function exceptionCreator) { - withRule(Strings::isNullOrEmpty, exceptionCreator); - return this; - } - - // ================================ - // #endregion - isNullOrEmpty - // ================================ - // ================================ // #region - length // ================================ diff --git a/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/ObjectPropertyValidatorTests.java b/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/ObjectPropertyValidatorTests.java index 9cca8e8..5405bb9 100644 --- a/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/ObjectPropertyValidatorTests.java +++ b/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/ObjectPropertyValidatorTests.java @@ -13,32 +13,326 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + package xyz.zhouxy.plusone.example.validator; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import java.time.DateTimeException; import java.time.LocalDateTime; +import java.util.Objects; import org.junit.jupiter.api.Test; import com.google.common.collect.Lists; +import xyz.zhouxy.plusone.commons.collection.CollectionTools; +import xyz.zhouxy.plusone.commons.util.DateTimeTools; +import xyz.zhouxy.plusone.commons.util.StringTools; import xyz.zhouxy.plusone.example.ExampleCommand; import xyz.zhouxy.plusone.example.Foo; +import xyz.zhouxy.plusone.validator.BaseValidator; public class ObjectPropertyValidatorTests { - // TODO + // ================================ + // #region - withRule + // ================================ - static ExampleCommand exampleCommand() { - return new ExampleCommand( + @Test + void withRule() { + BaseValidator validator = new BaseValidator() { + { + ruleFor(ExampleCommand::getBoolProperty) + .notNull("The boolProperty cannot be null.") + .withRule(Boolean.TRUE::equals, "The boolProperty should be true."); + + ruleFor(ExampleCommand::getIntProperty) + .withRule(intProperty -> intProperty > 0, "The intProperty should be greater than 0."); + + ruleFor(ExampleCommand::getLongProperty) + .withRule(longProperty -> longProperty > 0L, + () -> ExampleException.withMessage("The longProperty should be greater than 0.")); + + ruleFor(ExampleCommand::getDoubleProperty) + .withRule(doubleProperty -> doubleProperty > 0.00, + doubleProperty -> ExampleException.withMessage("The doubleProperty should be greater than 0, but it was: %s", doubleProperty)); + + ruleFor(ExampleCommand::getStringProperty) + .notNull() + .withRule(stringProperty -> stringProperty.length() > 2, + () -> ExampleException.withMessage("The length of stringProperty should be greater than 2.")); + + ruleFor(ExampleCommand::getDateTimeProperty) + .withRule(DateTimeTools::isFuture, + () -> new DateTimeException("The dateTimeProperty should be a future time.")); + + ruleFor(ExampleCommand::getObjectProperty) + .notNull("The objectProperty cannot be null."); + + ruleFor(ExampleCommand::getStringListProperty) + .withRule(CollectionTools::isNotEmpty, "The stringListProperty cannot be empty."); + + withRule(command -> { + Foo objectProperty = command.getObjectProperty(); + if (!Objects.equals(command.getIntProperty(), objectProperty.getIntProperty())) { + throw ExampleException.withMessage("intProperty invalid."); + } + }); + } + }; + + ExampleCommand command = new ExampleCommand( true, Integer.MAX_VALUE, Long.MAX_VALUE, - 3.14, - "Foo", - LocalDateTime.of(2008, 8, 8, 20, 8), - new Foo(Integer.MIN_VALUE, "Bar"), - Lists.newArrayList("A", "B", "C", "D")); + Double.MAX_VALUE, + "StringValue", + LocalDateTime.now().plusDays(1), + new Foo(Integer.MAX_VALUE, "StringValue"), + Lists.newArrayList("ABC", "DEF")); + + assertDoesNotThrow(() -> validator.validate(command)); } + + // ================================ + // #endregion - withRule + // ================================ + + // ================================ + // #region - notNull + // ================================ + + @Test + void notNull_validInput() { + BaseValidator validator = new BaseValidator() { + { + ruleForBool(ExampleCommand::getBoolProperty) + .notNull(); + ruleForInt(ExampleCommand::getIntProperty) + .notNull("The intProperty cannot be null"); + ruleForLong(ExampleCommand::getLongProperty) + .notNull(() -> ExampleException.withMessage("The longProperty cannot be null")); + ruleForDouble(ExampleCommand::getDoubleProperty) + .notNull(d -> ExampleException.withMessage("The doubleProperty cannot be null, but it was %s", d)); + ruleForString(ExampleCommand::getStringProperty) + .notNull(); + ruleForComparable(ExampleCommand::getDateTimeProperty) + .notNull("The dateTimeProperty cannot be null"); + ruleFor(ExampleCommand::getObjectProperty) + .notNull(() -> ExampleException.withMessage("The objectProperty cannot be null")); + ruleForCollection(ExampleCommand::getStringListProperty) + .notNull(d -> ExampleException.withMessage("The stringListProperty cannot be null, but it was %s", d)); + } + }; + ExampleCommand command = new ExampleCommand( + true, + Integer.MAX_VALUE, + Long.MAX_VALUE, + Double.MAX_VALUE, + "StringValue", + LocalDateTime.now().plusDays(1), + new Foo(Integer.MAX_VALUE, "StringValue"), + Lists.newArrayList("ABC", "DEF")); + + assertDoesNotThrow(() -> validator.validate(command)); + } + + @Test + void notNull_invalidInput() { + ExampleCommand command = new ExampleCommand(); + + BaseValidator defaultRule = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .notNull(); + } + }; + IllegalArgumentException eWithDefaultMessage = assertThrows( + IllegalArgumentException.class, () -> defaultRule.validate(command)); + assertEquals("Value could not be null.", eWithDefaultMessage.getMessage()); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .notNull("The objectProperty could not be null."); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, () -> ruleWithMessage.validate(command)); + assertEquals("The objectProperty could not be null.", eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .notNull(() -> ExampleException.withMessage("The objectProperty could not be null.")); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, () -> ruleWithExceptionSupplier.validate(command)); + assertEquals("The objectProperty could not be null.", specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .notNull(str -> ExampleException.withMessage("The objectProperty could not be null, but is was " + str)); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, () -> ruleWithExceptionFunction.validate(command)); + assertEquals("The objectProperty could not be null, but is was null", specifiedException2.getMessage()); + } + + // ================================ + // #endregion - notNull + // ================================ + + // ================================ + // #region - isNull + // ================================ + + @Test + void isNull_validInput() { + BaseValidator validator = new BaseValidator() { + { + ruleForBool(ExampleCommand::getBoolProperty) + .isNull("The boolProperty should be null"); + ruleForInt(ExampleCommand::getIntProperty) + .isNull("The intProperty should be null"); + ruleForLong(ExampleCommand::getLongProperty) + .isNull(() -> ExampleException.withMessage("The longProperty should be null")); + ruleForDouble(ExampleCommand::getDoubleProperty) + .isNull(d -> ExampleException.withMessage("The doubleProperty should be null, but it was %s", d)); + ruleForString(ExampleCommand::getStringProperty) + .isNull("The stringProperty should be null"); + ruleForComparable(ExampleCommand::getDateTimeProperty) + .isNull("The dateTimeProperty should be null"); + ruleFor(ExampleCommand::getObjectProperty) + .isNull(() -> ExampleException.withMessage("The objectProperty should be null")); + ruleForCollection(ExampleCommand::getStringListProperty) + .isNull(d -> ExampleException.withMessage("The stringListProperty should be null, but it was %s", d)); + } + }; + ExampleCommand command = new ExampleCommand(); + + assertDoesNotThrow(() -> validator.validate(command)); + } + + @Test + void isNull_invalidInput() { + ExampleCommand command = new ExampleCommand(); + command.setObjectProperty(new Foo(Integer.MAX_VALUE, "StringValue")); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .isNull("The objectProperty should be null."); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, () -> ruleWithMessage.validate(command)); + assertEquals("The objectProperty should be null.", eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .isNull(() -> ExampleException.withMessage("The objectProperty should be null.")); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, () -> ruleWithExceptionSupplier.validate(command)); + assertEquals("The objectProperty should be null.", specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleFor(ExampleCommand::getObjectProperty) + .isNull(str -> ExampleException.withMessage("The objectProperty should be null, but is was " + str)); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, () -> ruleWithExceptionFunction.validate(command)); + assertEquals("The objectProperty should be null, but is was " + command.getObjectProperty(), specifiedException2.getMessage()); + } + + // ================================ + // #endregion - isNull + // ================================ + + // ================================ + // #region - equalsThat + // ================================ + + @Test + void equalsThat() { + + } + + @Test + void equalsThat2() { + + } + + @Test + void equalsThat3() { + + } + + @Test + void equalsThat4() { + + } + + // ================================ + // #endregion - equalsThat + // ================================ + + // ================================ + // #region - must + // ================================ + + @Test + void must() { + + } + + @Test + void must2() { + + } + + @Test + void must3() { + + } + + @Test + void must4() { + + } + + @Test + void must5() { + + } + + @Test + void must6() { + + } + + @Test + void must7() { + + } + + @Test + void must8() { + + } + + // ================================ + // #endregion - must + // ================================ } diff --git a/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/StringPropertyValidatorTests.java b/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/StringPropertyValidatorTests.java index a01f53e..2eb0aae 100644 --- a/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/StringPropertyValidatorTests.java +++ b/plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/StringPropertyValidatorTests.java @@ -22,6 +22,8 @@ import java.util.List; import java.util.regex.Pattern; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import com.google.common.collect.Lists; @@ -32,6 +34,12 @@ import xyz.zhouxy.plusone.validator.BaseValidator; public class StringPropertyValidatorTests { private static final String MESSAGE_SHOULD_MATCH = "Input should match pattern"; + private static final String MESSAGE_NOT_BLANK = "Input cannot be blank"; + private static final String MESSAGE_NOT_EMPTY = "Input cannot be empty"; + private static final String MESSAGE_NOT_EMAIL = "Input should be an email address"; + + private static final int MIN_LENGTH = 6; + private static final int MAX_LENGTH = 8; // ================================ // #region - matches @@ -112,10 +120,7 @@ public class StringPropertyValidatorTests { }; ExampleCommand command = exampleCommandWithStringProperty(null); - IllegalArgumentException e = assertThrows( - IllegalArgumentException.class, - () -> validator.validate(command)); - assertEquals(MESSAGE_SHOULD_MATCH, e.getMessage()); + assertDoesNotThrow(() -> validator.validate(command)); } @Test @@ -128,10 +133,7 @@ public class StringPropertyValidatorTests { }; ExampleCommand command = exampleCommandWithStringProperty(null); - ExampleException e = assertThrows( - ExampleException.class, - () -> validator.validate(command)); - assertEquals(MESSAGE_SHOULD_MATCH, e.getMessage()); + assertDoesNotThrow(() -> validator.validate(command)); } @Test @@ -145,10 +147,7 @@ public class StringPropertyValidatorTests { }; ExampleCommand command = exampleCommandWithStringProperty(null); - ExampleException e = assertThrows( - ExampleException.class, - () -> validator.validate(command)); - assertEquals("Input should match pattern, but it is null", e.getMessage()); + assertDoesNotThrow(() -> validator.validate(command)); } // ================================ @@ -729,47 +728,460 @@ public class StringPropertyValidatorTests { // #region - notBlank // ================================ - // TODO + @Test + void notBlank_all_validInput() { + BaseValidator validator = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank() + .notBlank(MESSAGE_NOT_BLANK) + .notBlank(() -> ExampleException.withMessage(MESSAGE_NOT_BLANK)) + .notBlank(str -> ExampleException.withMessage("The stringProperty cannot be blank, but is was %s", StringTools.toQuotedString(str))); + } + }; + + ExampleCommand command = exampleCommandWithStringProperty("abcd"); + assertDoesNotThrow(() -> validator.validate(command)); + } + + @ParameterizedTest + @ValueSource(strings = { "", " ", " ", "\t", "\n" }) + void notBlank_invalidInput(String value) { + ExampleCommand command = exampleCommandWithStringProperty(value); + + BaseValidator defaultRule = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(); + } + }; + IllegalArgumentException eWithDefaultMessage = assertThrows( + IllegalArgumentException.class, + () -> defaultRule.validate(command)); + assertEquals("The value must have text; it must not be null, empty, or blank.", eWithDefaultMessage.getMessage()); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(MESSAGE_NOT_BLANK); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals(MESSAGE_NOT_BLANK, eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(() -> ExampleException.withMessage(MESSAGE_NOT_BLANK)); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals(MESSAGE_NOT_BLANK, specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(str -> ExampleException.withMessage("The stringProperty cannot be blank, but is was %s", StringTools.toQuotedString(str))); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals("The stringProperty cannot be blank, but is was " + StringTools.toQuotedString(value), + specifiedException2.getMessage()); + } + + @Test + void notBlank_nullInput() { + ExampleCommand command = exampleCommandWithStringProperty(null); + + BaseValidator defaultRule = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(); + } + }; + IllegalArgumentException eWithDefaultMessage = assertThrows( + IllegalArgumentException.class, + () -> defaultRule.validate(command)); + assertEquals("The value must have text; it must not be null, empty, or blank.", eWithDefaultMessage.getMessage()); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(MESSAGE_NOT_BLANK); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals(MESSAGE_NOT_BLANK, eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(() -> ExampleException.withMessage(MESSAGE_NOT_BLANK)); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals(MESSAGE_NOT_BLANK, specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notBlank(str -> ExampleException.withMessage("The stringProperty cannot be blank, but is was %s", StringTools.toQuotedString(str))); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals("The stringProperty cannot be blank, but is was null", + specifiedException2.getMessage()); + } // ================================ // #endregion - notBlank // ================================ // ================================ - // #region - email + // #region - emailAddress // ================================ - // TODO + @Test + void emailAddress_validInput() { + BaseValidator validator = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .emailAddress() + .emailAddress(MESSAGE_NOT_EMAIL) + .emailAddress(() -> ExampleException.withMessage(MESSAGE_NOT_EMAIL)) + .emailAddress(str -> ExampleException.withMessage("Input should be an email address, but it was \"%s\"", str)); + } + }; + ExampleCommand validCommand = exampleCommandWithStringProperty("abc@example.com"); + assertDoesNotThrow(() -> validator.validate(validCommand)); + + ExampleCommand commandWithNullStringProperty = exampleCommandWithStringProperty(null); + assertDoesNotThrow(() -> validator.validate(commandWithNullStringProperty)); + } + + @ParameterizedTest + @ValueSource(strings = { "", "abc", "abc@def@example.com" }) + void emailAddress_invalidInput(String value) { + ExampleCommand command = exampleCommandWithStringProperty(value); + + BaseValidator defaultRule = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .emailAddress(); + } + }; + IllegalArgumentException eWithDefaultMessage = assertThrows( + IllegalArgumentException.class, + () -> defaultRule.validate(command)); + assertEquals("The value is not an email address.", eWithDefaultMessage.getMessage()); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .emailAddress(MESSAGE_NOT_EMAIL); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals(MESSAGE_NOT_EMAIL, eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .emailAddress(() -> ExampleException.withMessage(MESSAGE_NOT_EMAIL)); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals(MESSAGE_NOT_EMAIL, specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .emailAddress(str -> ExampleException.withMessage("Input should be an email address, but it was \"%s\"", str)); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals(String.format("Input should be an email address, but it was \"%s\"", value), specifiedException2.getMessage()); + } // ================================ - // #endregion - email + // #endregion - emailAddress // ================================ // ================================ // #region - notEmpty // ================================ - // TODO + @ParameterizedTest + @ValueSource(strings = { "abcd", " ", " ", "\t", "\n" }) + void notEmpty_all_validInput() { + BaseValidator validator = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty() + .notEmpty(MESSAGE_NOT_EMPTY) + .notEmpty(() -> ExampleException.withMessage(MESSAGE_NOT_EMPTY)) + .notEmpty(str -> ExampleException.withMessage("The stringProperty cannot be empty, but is was %s", StringTools.toQuotedString(str))); + } + }; + + ExampleCommand command = exampleCommandWithStringProperty("abcd"); + assertDoesNotThrow(() -> validator.validate(command)); + } + + @Test + void notEmpty_invalidInput() { + final String value = ""; + ExampleCommand command = exampleCommandWithStringProperty(value); + + BaseValidator defaultRule = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(); + } + }; + IllegalArgumentException eWithDefaultMessage = assertThrows( + IllegalArgumentException.class, + () -> defaultRule.validate(command)); + assertEquals("The value must not be empty.", eWithDefaultMessage.getMessage()); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(MESSAGE_NOT_EMPTY); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals(MESSAGE_NOT_EMPTY, eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(() -> ExampleException.withMessage(MESSAGE_NOT_EMPTY)); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals(MESSAGE_NOT_EMPTY, specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(str -> ExampleException.withMessage("The stringProperty cannot be empty, but is was %s", StringTools.toQuotedString(str))); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals("The stringProperty cannot be empty, but is was " + StringTools.toQuotedString(value), + specifiedException2.getMessage()); + } + + @Test + void notEmpty_nullInput() { + ExampleCommand command = exampleCommandWithStringProperty(null); + + BaseValidator defaultRule = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(); + } + }; + IllegalArgumentException eWithDefaultMessage = assertThrows( + IllegalArgumentException.class, + () -> defaultRule.validate(command)); + assertEquals("The value must not be empty.", eWithDefaultMessage.getMessage()); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(MESSAGE_NOT_EMPTY); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals(MESSAGE_NOT_EMPTY, eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(() -> ExampleException.withMessage(MESSAGE_NOT_EMPTY)); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals(MESSAGE_NOT_EMPTY, specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .notEmpty(str -> ExampleException.withMessage("The stringProperty cannot be empty, but is was %s", StringTools.toQuotedString(str))); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals("The stringProperty cannot be empty, but is was null", + specifiedException2.getMessage()); + } // ================================ // #endregion - notEmpty // ================================ - // ================================ - // #region - isNullOrEmpty - // ================================ - - // TODO - - // ================================ - // #endregion - isNullOrEmpty - // ================================ - // ================================ // #region - length // ================================ - // TODO + @Test + void length_specifiedLength_validLength() { + BaseValidator validator = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, "The length of the string must be 6") + .length(MIN_LENGTH, () -> ExampleException.withMessage("The length of the string must be 6")) + .length(MIN_LENGTH, str -> ExampleException.withMessage("The length of the string must be 6, but it was %d", str.length())); + } + }; + ExampleCommand validCommand = exampleCommandWithStringProperty("123456"); + assertDoesNotThrow(() -> validator.validate(validCommand)); + + ExampleCommand commandWithNullStringProperty = exampleCommandWithStringProperty(null); + assertDoesNotThrow(() -> validator.validate(commandWithNullStringProperty)); + } + + @ParameterizedTest + @ValueSource(strings = { "", "12345", "1234567" }) + void length_specifiedLength_invalidLength(String value) { + ExampleCommand command = exampleCommandWithStringProperty(value); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, "The length of the string must be 6"); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals("The length of the string must be 6", eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, () -> ExampleException.withMessage("The length of the string must be 6")); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals("The length of the string must be 6", specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, str -> ExampleException.withMessage("The length of the string must be 6, but it was %d", str.length())); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals( + String.format("The length of the string must be 6, but it was %d", value.length()), + specifiedException2.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = { "123456", "1234567", "12345678" }) + void length_specifiedMinLengthAndMaxLength_validLength(String value) { + ExampleCommand command = exampleCommandWithStringProperty(value); + BaseValidator validator = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, MAX_LENGTH, String.format("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH)) + .length(MIN_LENGTH, MAX_LENGTH, () -> ExampleException.withMessage("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH)) + .length(MIN_LENGTH, MAX_LENGTH, str -> ExampleException.withMessage("Length of StringProperty is %d, min length is %d, max length is %d", str.length(), MIN_LENGTH, MAX_LENGTH)); + } + }; + assertDoesNotThrow(() -> validator.validate(command)); + } + + @Test + void length_specifiedMinLengthAndMaxLength_null() { + ExampleCommand command = exampleCommandWithStringProperty(null); + BaseValidator validator = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, MAX_LENGTH, String.format("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH)) + .length(MIN_LENGTH, MAX_LENGTH, () -> ExampleException.withMessage("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH)) + .length(MIN_LENGTH, MAX_LENGTH, str -> ExampleException.withMessage("Length of StringProperty is %d, min length is %d, max length is %d", str.length(), MIN_LENGTH, MAX_LENGTH)); + } + }; + assertDoesNotThrow(() -> validator.validate(command)); + } + + @ParameterizedTest + @ValueSource(strings = { "", "12345", "123456789" }) + void length_specifiedMinLengthAndMaxLength_invalidLength(String value) { + ExampleCommand command = exampleCommandWithStringProperty(value); + + BaseValidator ruleWithMessage = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, MAX_LENGTH, String.format("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH)); + } + }; + IllegalArgumentException eWithSpecifiedMessage = assertThrows( + IllegalArgumentException.class, + () -> ruleWithMessage.validate(command)); + assertEquals("Min length is 6, max length is 8", eWithSpecifiedMessage.getMessage()); + + BaseValidator ruleWithExceptionSupplier = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, MAX_LENGTH, () -> ExampleException.withMessage("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH)); + } + }; + ExampleException specifiedException = assertThrows( + ExampleException.class, + () -> ruleWithExceptionSupplier.validate(command)); + assertEquals("Min length is 6, max length is 8", specifiedException.getMessage()); + + BaseValidator ruleWithExceptionFunction = new BaseValidator() { + { + ruleForString(ExampleCommand::getStringProperty) + .length(MIN_LENGTH, MAX_LENGTH, str -> ExampleException.withMessage("Length of StringProperty is %d, min length is %d, max length is %d", str.length(), MIN_LENGTH, MAX_LENGTH)); + } + }; + ExampleException specifiedException2 = assertThrows( + ExampleException.class, + () -> ruleWithExceptionFunction.validate(command)); + assertEquals( + String.format("Length of StringProperty is %d, min length is %d, max length is %d", value.length(), MIN_LENGTH, MAX_LENGTH), + specifiedException2.getMessage()); + } // ================================ // #endregion - length