From a4b0afbd2b687a4252e2f8aa61bcec30b10de4a0 Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Sat, 2 Mar 2024 13:25:43 -0300 Subject: [PATCH] chore: validators unit test --- .../validator/number/IsNotOneValidator.kt | 2 +- .../validator/number/IsNotZeroValidator.kt | 2 +- .../state/validator/number/IsOneValidator.kt | 2 +- .../state/validator/number/IsZeroValidator.kt | 2 +- .../state/validator/AnyValidatorsTest.kt | 229 +++ .../validator/CharacterValidatorsTest.kt | 509 ++++++ .../validator/ComparableValidatorsTest.kt | 198 +++ .../state/validator/NumberValidatorsTest.kt | 326 ++++ .../state/validator/StringValidatorsTest.kt | 1486 +++++++++++++++++ 9 files changed, 2752 insertions(+), 4 deletions(-) create mode 100644 validators/common/test/dev/programadorthi/state/validator/AnyValidatorsTest.kt create mode 100644 validators/common/test/dev/programadorthi/state/validator/CharacterValidatorsTest.kt create mode 100644 validators/common/test/dev/programadorthi/state/validator/ComparableValidatorsTest.kt create mode 100644 validators/common/test/dev/programadorthi/state/validator/NumberValidatorsTest.kt create mode 100644 validators/common/test/dev/programadorthi/state/validator/StringValidatorsTest.kt diff --git a/validators/common/src/dev/programadorthi/state/validator/number/IsNotOneValidator.kt b/validators/common/src/dev/programadorthi/state/validator/number/IsNotOneValidator.kt index 025795a..7c4c65b 100644 --- a/validators/common/src/dev/programadorthi/state/validator/number/IsNotOneValidator.kt +++ b/validators/common/src/dev/programadorthi/state/validator/number/IsNotOneValidator.kt @@ -6,6 +6,6 @@ public class IsNotOneValidator( override val message: (Number) -> String ) : Validator { - override fun isValid(value: Number): Boolean = value != 1 + override fun isValid(value: Number): Boolean = value.toDouble() != 1.0 } \ No newline at end of file diff --git a/validators/common/src/dev/programadorthi/state/validator/number/IsNotZeroValidator.kt b/validators/common/src/dev/programadorthi/state/validator/number/IsNotZeroValidator.kt index 9217393..37e51a3 100644 --- a/validators/common/src/dev/programadorthi/state/validator/number/IsNotZeroValidator.kt +++ b/validators/common/src/dev/programadorthi/state/validator/number/IsNotZeroValidator.kt @@ -6,6 +6,6 @@ public class IsNotZeroValidator( override val message: (Number) -> String ) : Validator { - override fun isValid(value: Number): Boolean = value != 0 + override fun isValid(value: Number): Boolean = value.toDouble() != 0.0 } \ No newline at end of file diff --git a/validators/common/src/dev/programadorthi/state/validator/number/IsOneValidator.kt b/validators/common/src/dev/programadorthi/state/validator/number/IsOneValidator.kt index b92c188..8f7a269 100644 --- a/validators/common/src/dev/programadorthi/state/validator/number/IsOneValidator.kt +++ b/validators/common/src/dev/programadorthi/state/validator/number/IsOneValidator.kt @@ -6,6 +6,6 @@ public class IsOneValidator( override val message: (Number) -> String ) : Validator { - override fun isValid(value: Number): Boolean = value == 1 + override fun isValid(value: Number): Boolean = value.toDouble() == 1.0 } \ No newline at end of file diff --git a/validators/common/src/dev/programadorthi/state/validator/number/IsZeroValidator.kt b/validators/common/src/dev/programadorthi/state/validator/number/IsZeroValidator.kt index 8be1365..4366039 100644 --- a/validators/common/src/dev/programadorthi/state/validator/number/IsZeroValidator.kt +++ b/validators/common/src/dev/programadorthi/state/validator/number/IsZeroValidator.kt @@ -6,6 +6,6 @@ public class IsZeroValidator( override val message: (Number) -> String ) : Validator { - override fun isValid(value: Number): Boolean = value == 0 + override fun isValid(value: Number): Boolean = value.toDouble() == 0.0 } \ No newline at end of file diff --git a/validators/common/test/dev/programadorthi/state/validator/AnyValidatorsTest.kt b/validators/common/test/dev/programadorthi/state/validator/AnyValidatorsTest.kt new file mode 100644 index 0000000..9a28d05 --- /dev/null +++ b/validators/common/test/dev/programadorthi/state/validator/AnyValidatorsTest.kt @@ -0,0 +1,229 @@ +package dev.programadorthi.state.validator + +import dev.programadorthi.state.core.extension.basicValueManager +import dev.programadorthi.state.core.extension.plusAssign +import dev.programadorthi.state.validator.any.InValidator +import dev.programadorthi.state.validator.any.IsEqualToValidator +import dev.programadorthi.state.validator.any.IsNotEqualToValidator +import dev.programadorthi.state.validator.any.IsNotNullValidator +import dev.programadorthi.state.validator.any.IsNullValidator +import dev.programadorthi.state.validator.any.NotInValidator +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class AnyValidatorsTest { + + @Test + fun shouldBeValidWithInValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += InValidator( + values = listOf(1, 2, 3, 4, 5), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { it + 3 } + + // THEN + assertEquals(3, manager.value) + assertTrue(manager.isValid, "should be valid using in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid in validator") + } + + @Test + fun shouldBeInvalidWithInValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += InValidator( + values = listOf(1, 2, 3, 4, 5), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { it + 6 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using in validator") + assertEquals("6 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsEqualToValidator( + other = 4, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { it + 4 } + + // THEN + assertEquals(4, manager.value) + assertTrue(manager.isValid, "should be valid using is equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is equal to validator") + } + + @Test + fun shouldBeInvalidWithIsEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsEqualToValidator( + other = 7, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { it + 2 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is equal to validator") + assertEquals("2 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsNotEqualToValidator( + other = 1, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { it + 3 } + + // THEN + assertEquals(3, manager.value) + assertTrue(manager.isValid, "should be valid using is not equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not equal to validator") + } + + @Test + fun shouldBeInvalidWithIsNotEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsNotEqualToValidator( + other = 9, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { it + 9 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is not equal to validator") + assertEquals("9 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotNullValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsNotNullValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 5 } + + // THEN + assertEquals(5, manager.value) + assertTrue(manager.isValid, "should be valid using is not null validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not null validator") + } + + @Test + fun shouldBeInvalidWithIsNotNullValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsNotNullValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { null } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is not null validator") + assertEquals("null is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNullValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsNullValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { null } + + // THEN + assertEquals(null, manager.value) + assertTrue(manager.isValid, "should be valid using is null validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is null validator") + } + + @Test + fun shouldBeInvalidWithIsNullValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsNullValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 1 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is null validator") + assertEquals("1 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotInValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += NotInValidator( + values = listOf(1, 2, 3, 4, 5), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 9 } + + // THEN + assertEquals(9, manager.value) + assertTrue(manager.isValid, "should be valid using not in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not in validator") + } + + @Test + fun shouldBeInvalidWithNotInValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += NotInValidator( + values = listOf(1, 2, 3, 4, 5), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 2 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using not in validator") + assertEquals("2 is invalid", manager.messages.first()) + } +} \ No newline at end of file diff --git a/validators/common/test/dev/programadorthi/state/validator/CharacterValidatorsTest.kt b/validators/common/test/dev/programadorthi/state/validator/CharacterValidatorsTest.kt new file mode 100644 index 0000000..20b1119 --- /dev/null +++ b/validators/common/test/dev/programadorthi/state/validator/CharacterValidatorsTest.kt @@ -0,0 +1,509 @@ +package dev.programadorthi.state.validator + +import dev.programadorthi.state.core.extension.basicValueManager +import dev.programadorthi.state.core.extension.plusAssign +import dev.programadorthi.state.validator.character.InValidator +import dev.programadorthi.state.validator.character.IsDigitValidator +import dev.programadorthi.state.validator.character.IsEqualToValidator +import dev.programadorthi.state.validator.character.IsLetterOrDigitValidator +import dev.programadorthi.state.validator.character.IsLetterValidator +import dev.programadorthi.state.validator.character.IsLowerCaseValidator +import dev.programadorthi.state.validator.character.IsNotDigitValidator +import dev.programadorthi.state.validator.character.IsNotEqualToValidator +import dev.programadorthi.state.validator.character.IsNotLetterOrDigitValidator +import dev.programadorthi.state.validator.character.IsNotLetterValidator +import dev.programadorthi.state.validator.character.IsNotWhitespaceValidator +import dev.programadorthi.state.validator.character.IsUpperCaseValidator +import dev.programadorthi.state.validator.character.IsWhitespaceValidator +import dev.programadorthi.state.validator.character.NotInValidator +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class CharacterValidatorsTest { + + @Test + fun shouldBeValidWithInValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += InValidator( + values = listOf('1', '2', '3', '4', '5'), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '3' } + + // THEN + assertEquals('3', manager.value) + assertTrue(manager.isValid, "should be valid using in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid in validator") + } + + @Test + fun shouldBeInvalidWithInValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += InValidator( + values = listOf('1', '2', '3', '4', '5'), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '6' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using in validator") + assertEquals("6 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '9' } + + // THEN + assertEquals('9', manager.value) + assertTrue(manager.isValid, "should be valid using is digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is digit validator") + } + + @Test + fun shouldBeInvalidWithIsDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'D' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is digit validator") + assertEquals("D is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsEqualToValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsEqualToValidator( + other = 'E', + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'E' } + + // THEN + assertEquals('E', manager.value) + assertTrue(manager.isValid, "should be valid using is equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is equal to validator") + } + + @Test + fun shouldBeInvalidWithIsEqualToValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsEqualToValidator( + other = 'D', + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'E' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is equal to validator") + assertEquals("E is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'E' } + + // THEN + assertEquals('E', manager.value) + assertTrue(manager.isValid, "should be valid using is letter or digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is letter or digit validator") + } + + @Test + fun shouldBeInvalidWithIsLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '#' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is letter or digit validator") + assertEquals("# is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsLetterValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'E' } + + // THEN + assertEquals('E', manager.value) + assertTrue(manager.isValid, "should be valid using is letter validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is letter validator") + } + + @Test + fun shouldBeInvalidWithIsLetterValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '3' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is letter validator") + assertEquals("3 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsLowerCaseValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'e' } + + // THEN + assertEquals('e', manager.value) + assertTrue(manager.isValid, "should be valid using is lower case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is lower case validator") + } + + @Test + fun shouldBeInvalidWithIsLowerCaseValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'E' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is lower case validator") + assertEquals("E is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'e' } + + // THEN + assertEquals('e', manager.value) + assertTrue(manager.isValid, "should be valid using is not digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not digit validator") + } + + @Test + fun shouldBeInvalidWithIsNotDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '8' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is not digit validator") + assertEquals("8 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotEqualToValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotEqualToValidator( + other = 'a', + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'e' } + + // THEN + assertEquals('e', manager.value) + assertTrue(manager.isValid, "should be valid using is not equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not equal to validator") + } + + @Test + fun shouldBeInvalidWithIsNotEqualToValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotEqualToValidator( + other = '8', + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '8' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is not equal to validator") + assertEquals("8 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '@' } + + // THEN + assertEquals('@', manager.value) + assertTrue(manager.isValid, "should be valid using is not letter or digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not letter or digit validator") + } + + @Test + fun shouldBeInvalidWithIsNotLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '8' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is not letter or digit validator") + assertEquals("8 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotLetterValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '@' } + + // THEN + assertEquals('@', manager.value) + assertTrue(manager.isValid, "should be valid using is not letter validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not letter validator") + } + + @Test + fun shouldBeInvalidWithIsNotLetterValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'a' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is not letter validator") + assertEquals("a is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotWhitespaceValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '@' } + + // THEN + assertEquals('@', manager.value) + assertTrue(manager.isValid, "should be valid using is not whitespace validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not whitespace validator") + } + + @Test + fun shouldBeInvalidWithIsNotWhitespaceValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsNotWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { ' ' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is not whitespace validator") + assertEquals(" is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsUpperCaseValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'P' } + + // THEN + assertEquals('P', manager.value) + assertTrue(manager.isValid, "should be valid using is upper case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is upper case validator") + } + + @Test + fun shouldBeInvalidWithIsUpperCaseValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'p' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is upper case validator") + assertEquals("p is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsWhitespaceValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { ' ' } + + // THEN + assertEquals(' ', manager.value) + assertTrue(manager.isValid, "should be valid using is whitespace validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is whitespace validator") + } + + @Test + fun shouldBeInvalidWithIsWhitespaceValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += IsWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 'p' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using is whitespace validator") + assertEquals("p is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotInValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += NotInValidator( + values = listOf('1', '2', '3', '4', '5'), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '9' } + + // THEN + assertEquals('9', manager.value) + assertTrue(manager.isValid, "should be valid using not in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not in validator") + } + + @Test + fun shouldBeInvalidWithNotInValidator() { + // GIVEN + val manager = basicValueManager('0') + manager += NotInValidator( + values = listOf('1', '2', '3', '4', '5'), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { '4' } + + // THEN + assertEquals('0', manager.value) + assertFalse(manager.isValid, "should be invalid using not in validator") + assertEquals("4 is invalid", manager.messages.first()) + } +} \ No newline at end of file diff --git a/validators/common/test/dev/programadorthi/state/validator/ComparableValidatorsTest.kt b/validators/common/test/dev/programadorthi/state/validator/ComparableValidatorsTest.kt new file mode 100644 index 0000000..b3ab1d6 --- /dev/null +++ b/validators/common/test/dev/programadorthi/state/validator/ComparableValidatorsTest.kt @@ -0,0 +1,198 @@ +package dev.programadorthi.state.validator + +import dev.programadorthi.state.core.extension.basicValueManager +import dev.programadorthi.state.core.extension.plusAssign +import dev.programadorthi.state.validator.comparable.InValidator +import dev.programadorthi.state.validator.comparable.IsGreaterThanOrEqualToValidator +import dev.programadorthi.state.validator.comparable.IsGreaterThanValidator +import dev.programadorthi.state.validator.comparable.IsLessThanOrEqualToValidator +import dev.programadorthi.state.validator.comparable.IsLessThanValidator +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class ComparableValidatorsTest { + + @Test + fun shouldBeValidWithInValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += InValidator( + start = 5, + end = 16, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 13 } + + // THEN + assertEquals(13, manager.value) + assertTrue(manager.isValid, "should be valid using in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid in validator") + } + + @Test + fun shouldBeInvalidWithInValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += InValidator( + start = 5, + end = 16, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 44 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using in validator") + assertEquals("44 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsGreaterThanOrEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsGreaterThanOrEqualToValidator( + start = 5, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 13 } + + // THEN + assertEquals(13, manager.value) + assertTrue(manager.isValid, "should be valid using is greater than or equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is greater than or equal to validator") + } + + @Test + fun shouldBeInvalidWithIsGreaterThanOrEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsGreaterThanOrEqualToValidator( + start = 15, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 4 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is greater than or equal to validator") + assertEquals("4 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsGreaterThanValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsGreaterThanValidator( + start = 5, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 13 } + + // THEN + assertEquals(13, manager.value) + assertTrue(manager.isValid, "should be valid using is greater than validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is greater than validator") + } + + @Test + fun shouldBeInvalidWithIsGreaterThanValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsGreaterThanValidator( + start = 5, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 4 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is greater than validator") + assertEquals("4 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsLessThanOrEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsLessThanOrEqualToValidator( + end = 55, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 13 } + + // THEN + assertEquals(13, manager.value) + assertTrue(manager.isValid, "should be valid using is less than or equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is less than or equal to validator") + } + + @Test + fun shouldBeInvalidWithIsLessThanOrEqualToValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsLessThanOrEqualToValidator( + end = 15, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 44 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is less than or equal to validator") + assertEquals("44 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsLessThanValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsLessThanValidator( + end = 55, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 13 } + + // THEN + assertEquals(13, manager.value) + assertTrue(manager.isValid, "should be valid using is less than validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is less than validator") + } + + @Test + fun shouldBeInvalidWithIsLessThanValidator() { + // GIVEN + val manager = basicValueManager(0) + manager += IsLessThanValidator( + end = 5, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 44 } + + // THEN + assertEquals(0, manager.value) + assertFalse(manager.isValid, "should be invalid using is less than validator") + assertEquals("44 is invalid", manager.messages.first()) + } +} \ No newline at end of file diff --git a/validators/common/test/dev/programadorthi/state/validator/NumberValidatorsTest.kt b/validators/common/test/dev/programadorthi/state/validator/NumberValidatorsTest.kt new file mode 100644 index 0000000..d0ec2bd --- /dev/null +++ b/validators/common/test/dev/programadorthi/state/validator/NumberValidatorsTest.kt @@ -0,0 +1,326 @@ +package dev.programadorthi.state.validator + +import dev.programadorthi.state.core.extension.basicValueManager +import dev.programadorthi.state.core.extension.plusAssign +import dev.programadorthi.state.validator.number.IsFiniteValidator +import dev.programadorthi.state.validator.number.IsInfiniteValidator +import dev.programadorthi.state.validator.number.IsNaNValidator +import dev.programadorthi.state.validator.number.IsNegativeValidator +import dev.programadorthi.state.validator.number.IsNotOneValidator +import dev.programadorthi.state.validator.number.IsNotZeroValidator +import dev.programadorthi.state.validator.number.IsOneValidator +import dev.programadorthi.state.validator.number.IsPositiveValidator +import dev.programadorthi.state.validator.number.IsZeroValidator +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class NumberValidatorsTest { + + @Test + fun shouldBeValidWithIsFiniteValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsFiniteValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { Double.MAX_VALUE } + + // THEN + assertEquals(Double.MAX_VALUE, manager.value) + assertTrue(manager.isValid, "should be valid using is finite validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is finite validator") + } + + @Test + fun shouldBeInvalidWithIsFiniteValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsFiniteValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { Double.POSITIVE_INFINITY } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is finite validator") + assertEquals("${Double.POSITIVE_INFINITY} is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsInfiniteValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsInfiniteValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { Double.POSITIVE_INFINITY } + + // THEN + assertEquals(Double.POSITIVE_INFINITY, manager.value) + assertTrue(manager.isValid, "should be valid using is infinite validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is infinite validator") + } + + @Test + fun shouldBeInvalidWithIsInfiniteValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsInfiniteValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { Double.MAX_VALUE } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is infinite validator") + assertEquals("${Double.MAX_VALUE} is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNaNValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNaNValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { Double.NaN } + + // THEN + assertEquals(Double.NaN, manager.value) + assertTrue(manager.isValid, "should be valid using is NaN validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is NaN validator") + } + + @Test + fun shouldBeInvalidWithIsNaNValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNaNValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 45.88 } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is NaN validator") + assertEquals("45.88 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNegativeValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNegativeValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { -12.567 } + + // THEN + assertEquals(-12.567, manager.value) + assertTrue(manager.isValid, "should be valid using is negative validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is negative validator") + } + + @Test + fun shouldBeInvalidWithIsNegativeValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNegativeValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 12.567 } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is negative validator") + assertEquals("12.567 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotOneValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNotOneValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 7.8 } + + // THEN + assertEquals(7.8, manager.value) + assertTrue(manager.isValid, "should be valid using is not one validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not one validator") + } + + @Test + fun shouldBeInvalidWithIsNotOneValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNotOneValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 1.0 } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is not one validator") + assertEquals("1.0 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotZeroValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsNotZeroValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 1.0 } + + // THEN + assertEquals(1.0, manager.value) + assertTrue(manager.isValid, "should be valid using is not zero validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not zero validator") + } + + @Test + fun shouldBeInvalidWithIsNotZeroValidator() { + // GIVEN + val manager = basicValueManager(1.0) + manager += IsNotZeroValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 0.0 } + + // THEN + assertEquals(1.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is not zero validator") + assertEquals("0.0 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsOneValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsOneValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 1.0 } + + // THEN + assertEquals(1.0, manager.value) + assertTrue(manager.isValid, "should be valid using is one validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is one validator") + } + + @Test + fun shouldBeInvalidWithIsOneValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsOneValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 10.0 } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is one validator") + assertEquals("10.0 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsPositiveValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsPositiveValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 1.0 } + + // THEN + assertEquals(1.0, manager.value) + assertTrue(manager.isValid, "should be valid using is positive validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is positive validator") + } + + @Test + fun shouldBeInvalidWithIsPositiveValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsPositiveValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { -10.0 } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is positive validator") + assertEquals("-10.0 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsZeroValidator() { + // GIVEN + val manager = basicValueManager(10.0) + manager += IsZeroValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 0.0 } + + // THEN + assertEquals(0.0, manager.value) + assertTrue(manager.isValid, "should be valid using is zero validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is zero validator") + } + + @Test + fun shouldBeInvalidWithIsZeroValidator() { + // GIVEN + val manager = basicValueManager(0.0) + manager += IsZeroValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { 10.0 } + + // THEN + assertEquals(0.0, manager.value) + assertFalse(manager.isValid, "should be invalid using is zero validator") + assertEquals("10.0 is invalid", manager.messages.first()) + } +} \ No newline at end of file diff --git a/validators/common/test/dev/programadorthi/state/validator/StringValidatorsTest.kt b/validators/common/test/dev/programadorthi/state/validator/StringValidatorsTest.kt new file mode 100644 index 0000000..c2c5a94 --- /dev/null +++ b/validators/common/test/dev/programadorthi/state/validator/StringValidatorsTest.kt @@ -0,0 +1,1486 @@ +package dev.programadorthi.state.validator + +import dev.programadorthi.state.core.extension.basicValueManager +import dev.programadorthi.state.core.extension.plusAssign +import dev.programadorthi.state.validator.string.AllDigitValidator +import dev.programadorthi.state.validator.string.AllLetterOrDigitValidator +import dev.programadorthi.state.validator.string.AllLetterValidator +import dev.programadorthi.state.validator.string.AllLowerCaseValidator +import dev.programadorthi.state.validator.string.AllUpperCaseValidator +import dev.programadorthi.state.validator.string.AllWhitespaceValidator +import dev.programadorthi.state.validator.string.AnyDigitValidator +import dev.programadorthi.state.validator.string.AnyLetterOrDigitValidator +import dev.programadorthi.state.validator.string.AnyLetterValidator +import dev.programadorthi.state.validator.string.AnyLowerCaseValidator +import dev.programadorthi.state.validator.string.AnyUpperCaseValidator +import dev.programadorthi.state.validator.string.AnyWhitespaceValidator +import dev.programadorthi.state.validator.string.ContainsAllValidator +import dev.programadorthi.state.validator.string.ContainsAnyValidator +import dev.programadorthi.state.validator.string.ContainsValidator +import dev.programadorthi.state.validator.string.EndsWithValidator +import dev.programadorthi.state.validator.string.HasSizeValidator +import dev.programadorthi.state.validator.string.InValidator +import dev.programadorthi.state.validator.string.IsEqualToValidator +import dev.programadorthi.state.validator.string.IsNotBlankValidator +import dev.programadorthi.state.validator.string.IsNotEmptyValidator +import dev.programadorthi.state.validator.string.IsNotEqualToValidator +import dev.programadorthi.state.validator.string.IsNullOrBlankValidator +import dev.programadorthi.state.validator.string.IsNullOrEmptyValidator +import dev.programadorthi.state.validator.string.NoneDigitValidator +import dev.programadorthi.state.validator.string.NoneLetterOrDigitValidator +import dev.programadorthi.state.validator.string.NoneLetterValidator +import dev.programadorthi.state.validator.string.NoneLowerCaseValidator +import dev.programadorthi.state.validator.string.NoneUpperCaseValidator +import dev.programadorthi.state.validator.string.NoneWhitespaceValidator +import dev.programadorthi.state.validator.string.NotContainsAllValidator +import dev.programadorthi.state.validator.string.NotContainsAnyValidator +import dev.programadorthi.state.validator.string.NotContainsValidator +import dev.programadorthi.state.validator.string.NotEndsWithValidator +import dev.programadorthi.state.validator.string.NotInValidator +import dev.programadorthi.state.validator.string.NotStartsWithValidator +import dev.programadorthi.state.validator.string.RegexContainsValidator +import dev.programadorthi.state.validator.string.RegexMatchValidator +import dev.programadorthi.state.validator.string.RegexNotContainsValidator +import dev.programadorthi.state.validator.string.RegexNotMatchValidator +import dev.programadorthi.state.validator.string.StartsWithValidator +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class StringValidatorsTest { + + @Test + fun shouldBeValidWithAllDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123456" } + + // THEN + assertEquals("123456", manager.value) + assertTrue(manager.isValid, "should be valid using all digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid all digit validator") + } + + @Test + fun shouldBeInvalidWithAllDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123abc456" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using all digit validator") + assertEquals("123abc456 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAllLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123abc456" } + + // THEN + assertEquals("123abc456", manager.value) + assertTrue(manager.isValid, "should be valid using all letter or digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid all letter or digit validator") + } + + @Test + fun shouldBeInvalidWithAllLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123abc456@#$%" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using all letter or digit validator") + assertEquals("123abc456@#$% is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAllLetterValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("abc", manager.value) + assertTrue(manager.isValid, "should be valid using all letter validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid all letter validator") + } + + @Test + fun shouldBeInvalidWithAllLetterValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123abc" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using all letter validator") + assertEquals("123abc is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAllLowerCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("abc", manager.value) + assertTrue(manager.isValid, "should be valid using all lower case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid all lower case validator") + } + + @Test + fun shouldBeInvalidWithAllLowerCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abCdeF" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using all lower case validator") + assertEquals("abCdeF is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAllUpperCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ABC" } + + // THEN + assertEquals("ABC", manager.value) + assertTrue(manager.isValid, "should be valid using all upper case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid all upper case validator") + } + + @Test + fun shouldBeInvalidWithAllUpperCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abCdeF" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using all upper case validator") + assertEquals("abCdeF is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAllWhitespaceValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { " " } + + // THEN + assertEquals(" ", manager.value) + assertTrue(manager.isValid, "should be valid using all whitespace validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid all whitespace validator") + } + + @Test + fun shouldBeInvalidWithAllWhitespaceValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AllWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { " a " } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using all whitespace validator") + assertEquals(" a is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAnyDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ab12cdthff445" } + + // THEN + assertEquals("ab12cdthff445", manager.value) + assertTrue(manager.isValid, "should be valid using any digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid any digit validator") + } + + @Test + fun shouldBeInvalidWithAnyDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc@#$" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using any digit validator") + assertEquals("abc@#$ is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAnyLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123abc456" } + + // THEN + assertEquals("123abc456", manager.value) + assertTrue(manager.isValid, "should be valid using any letter or digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid any letter or digit validator") + } + + @Test + fun shouldBeInvalidWithAnyLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "@#$%" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using any letter or digit validator") + assertEquals("@#$% is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAnyLetterValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123bf456hytu8" } + + // THEN + assertEquals("123bf456hytu8", manager.value) + assertTrue(manager.isValid, "should be valid using any letter validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid any letter validator") + } + + @Test + fun shouldBeInvalidWithAnyLetterValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123@#$%" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using any letter validator") + assertEquals("123@#$% is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAnyLowerCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "AMNCerdt4567" } + + // THEN + assertEquals("AMNCerdt4567", manager.value) + assertTrue(manager.isValid, "should be valid using any lower case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid any lower case validator") + } + + @Test + fun shouldBeInvalidWithAnyLowerCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "AMNC4567" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using any lower case validator") + assertEquals("AMNC4567 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAnyUpperCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "testAB2345" } + + // THEN + assertEquals("testAB2345", manager.value) + assertTrue(manager.isValid, "should be valid using any upper case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid any upper case validator") + } + + @Test + fun shouldBeInvalidWithAnyUpperCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc123de456" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using any upper case validator") + assertEquals("abc123de456 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithAnyWhitespaceValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc 123 " } + + // THEN + assertEquals("abc 123 ", manager.value) + assertTrue(manager.isValid, "should be valid using any whitespace validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid any whitespace validator") + } + + @Test + fun shouldBeInvalidWithAnyWhitespaceValidator() { + // GIVEN + val manager = basicValueManager("") + manager += AnyWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "VALUE_WITH_NO_SPACE" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using any whitespace validator") + assertEquals("VALUE_WITH_NO_SPACE is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithContainsAllValidator() { + // GIVEN + val manager = basicValueManager("") + manager += ContainsAllValidator( + targets = listOf("ab", "cd", "ef"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abcdef" } + + // THEN + assertEquals("abcdef", manager.value) + assertTrue(manager.isValid, "should be valid using contains all validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid contains all validator") + } + + @Test + fun shouldBeInvalidWithContainsAllValidator() { + // GIVEN + val manager = basicValueManager("") + manager += ContainsAllValidator( + targets = listOf("ab", "cd", "ef"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "cd" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using contains all validator") + assertEquals("cd is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithContainsAnyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += ContainsAnyValidator( + targets = listOf("ab", "cd", "ef"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "cd" } + + // THEN + assertEquals("cd", manager.value) + assertTrue(manager.isValid, "should be valid using contains any validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid contains any validator") + } + + @Test + fun shouldBeInvalidWithContainsAnyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += ContainsAnyValidator( + targets = listOf("ab", "cd", "ef"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "gh" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using contains any validator") + assertEquals("gh is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += ContainsValidator( + target = "xy", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "opqrstuvwxyz" } + + // THEN + assertEquals("opqrstuvwxyz", manager.value) + assertTrue(manager.isValid, "should be valid using contains validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid contains validator") + } + + @Test + fun shouldBeInvalidWithContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += ContainsValidator( + target = "xy", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "opqrstuvwz" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using contains validator") + assertEquals("opqrstuvwz is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithEndsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += EndsWithValidator( + suffix = "xyz", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "opqrstuvwxyz" } + + // THEN + assertEquals("opqrstuvwxyz", manager.value) + assertTrue(manager.isValid, "should be valid using ends with validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid ends with validator") + } + + @Test + fun shouldBeInvalidWithEndsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += EndsWithValidator( + suffix = "xyz", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "opqrstuvw" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using ends with validator") + assertEquals("opqrstuvw is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithHasSizeValidator() { + // GIVEN + val manager = basicValueManager("") + manager += HasSizeValidator( + minSize = 3, + maxSize = 10, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abcdef" } + + // THEN + assertEquals("abcdef", manager.value) + assertTrue(manager.isValid, "should be valid using has size validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid has size validator") + } + + @Test + fun shouldBeInvalidWithHasSizeValidator() { + // GIVEN + val manager = basicValueManager("") + manager += HasSizeValidator( + minSize = 3, + maxSize = 10, + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "a" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using has size validator") + assertEquals("a is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithInValidator() { + // GIVEN + val manager = basicValueManager("") + manager += InValidator( + values = listOf("abc", "123", "xyz"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("123", manager.value) + assertTrue(manager.isValid, "should be valid using in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid in validator") + } + + @Test + fun shouldBeInvalidWithInValidator() { + // GIVEN + val manager = basicValueManager("") + manager += InValidator( + values = listOf("abc", "123", "xyz"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "asdf" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using in validator") + assertEquals("asdf is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsEqualToValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsEqualToValidator( + other = "abc123", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc123" } + + // THEN + assertEquals("abc123", manager.value) + assertTrue(manager.isValid, "should be valid using is equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is equal to validator") + } + + @Test + fun shouldBeInvalidWithIsEqualToValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsEqualToValidator( + other = "abc123", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "xyz" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using is equal to validator") + assertEquals("xyz is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotBlankValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNotBlankValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc123" } + + // THEN + assertEquals("abc123", manager.value) + assertTrue(manager.isValid, "should be valid using is not blank validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not blank validator") + } + + @Test + fun shouldBeInvalidWithIsNotBlankValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNotBlankValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { " " } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using is not blank validator") + assertEquals(" is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotEmptyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNotEmptyValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc123" } + + // THEN + assertEquals("abc123", manager.value) + assertTrue(manager.isValid, "should be valid using is not empty validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not empty validator") + } + + @Test + fun shouldBeInvalidWithIsNotEmptyValidator() { + // GIVEN + val manager = basicValueManager("a") + manager += IsNotEmptyValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "" } + + // THEN + assertEquals("a", manager.value) + assertFalse(manager.isValid, "should be invalid using is not empty validator") + assertEquals(" is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNotEqualToValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNotEqualToValidator( + other = "xyz", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("abc", manager.value) + assertTrue(manager.isValid, "should be valid using is not equal to validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is not equal to validator") + } + + @Test + fun shouldBeInvalidWithIsNotEqualToValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNotEqualToValidator( + other = "123", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using is not equal to validator") + assertEquals("123 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNullOrBlankValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNullOrBlankValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { " " } + + // THEN + assertEquals(" ", manager.value) + assertTrue(manager.isValid, "should be valid using is null or blank validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is null or blank validator") + } + + @Test + fun shouldBeInvalidWithIsNullOrBlankValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNullOrBlankValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using is null or blank validator") + assertEquals("123 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithIsNullOrEmptyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNullOrEmptyValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "" } + + // THEN + assertEquals("", manager.value) + assertTrue(manager.isValid, "should be valid using is null or empty validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid is null or empty validator") + } + + @Test + fun shouldBeInvalidWithIsNullOrEmptyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += IsNullOrEmptyValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using is null or empty validator") + assertEquals("123 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNoneDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("abc", manager.value) + assertTrue(manager.isValid, "should be valid using none digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid none digit validator") + } + + @Test + fun shouldBeInvalidWithNoneDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using none digit validator") + assertEquals("123 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNoneLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "!@#$%" } + + // THEN + assertEquals("!@#$%", manager.value) + assertTrue(manager.isValid, "should be valid using none letter or digit validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid none letter or digit validator") + } + + @Test + fun shouldBeInvalidWithNoneLetterOrDigitValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneLetterOrDigitValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using none letter or digit validator") + assertEquals("123 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNoneLetterValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123" } + + // THEN + assertEquals("123", manager.value) + assertTrue(manager.isValid, "should be valid using none letter validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid none letter validator") + } + + @Test + fun shouldBeInvalidWithNoneLetterValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneLetterValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using none letter validator") + assertEquals("abc is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNoneLowerCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ABC" } + + // THEN + assertEquals("ABC", manager.value) + assertTrue(manager.isValid, "should be valid using none lower case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid none lower case validator") + } + + @Test + fun shouldBeInvalidWithNoneLowerCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneLowerCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using none lower case validator") + assertEquals("abc is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNoneUpperCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("abc", manager.value) + assertTrue(manager.isValid, "should be valid using none upper case validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid none upper case validator") + } + + @Test + fun shouldBeInvalidWithNoneUpperCaseValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneUpperCaseValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ABC" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using none upper case validator") + assertEquals("ABC is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNoneWhitespaceValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "abc" } + + // THEN + assertEquals("abc", manager.value) + assertTrue(manager.isValid, "should be valid using none whitespace validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid none whitespace validator") + } + + @Test + fun shouldBeInvalidWithNoneWhitespaceValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NoneWhitespaceValidator( + message = { "$it is invalid" } + ) + + // WHEN + manager.update { " " } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using none whitespace validator") + assertEquals(" is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotContainsAllValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotContainsAllValidator( + targets = listOf("12", "34", "56"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "12ab56" } + + // THEN + assertEquals("12ab56", manager.value) + assertTrue(manager.isValid, "should be valid using not contains all validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not contains all validator") + } + + @Test + fun shouldBeInvalidWithNotContainsAllValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotContainsAllValidator( + targets = listOf("12", "34", "56"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "123456" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using not contains all validator") + assertEquals("123456 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotContainsAnyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotContainsAnyValidator( + targets = listOf("12", "34", "56"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ab" } + + // THEN + assertEquals("ab", manager.value) + assertTrue(manager.isValid, "should be valid using not contains any validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not contains any validator") + } + + @Test + fun shouldBeInvalidWithNotContainsAnyValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotContainsAnyValidator( + targets = listOf("12", "34", "56"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ab34ef" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using not contains any validator") + assertEquals("ab34ef is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotContainsValidator( + target = "34", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ab12ef" } + + // THEN + assertEquals("ab12ef", manager.value) + assertTrue(manager.isValid, "should be valid using not contains validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not contains validator") + } + + @Test + fun shouldBeInvalidWithNotContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotContainsValidator( + target = "34", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "ab34ef" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using not contains validator") + assertEquals("ab34ef is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotEndsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotEndsWithValidator( + suffix = "ly", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "week" } + + // THEN + assertEquals("week", manager.value) + assertTrue(manager.isValid, "should be valid using not ends with validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not ends with validator") + } + + @Test + fun shouldBeInvalidWithNotEndsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotEndsWithValidator( + suffix = "ly", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "weekly" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using not ends with validator") + assertEquals("weekly is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotInValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotInValidator( + values = listOf("12", "34", "56", "78"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "90" } + + // THEN + assertEquals("90", manager.value) + assertTrue(manager.isValid, "should be valid using not in validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not in validator") + } + + @Test + fun shouldBeInvalidWithNotInValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotInValidator( + values = listOf("12", "34", "56", "78"), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "56" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using not in validator") + assertEquals("56 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithNotStartsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotStartsWithValidator( + prefix = "an", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "droid" } + + // THEN + assertEquals("droid", manager.value) + assertTrue(manager.isValid, "should be valid using not starts with validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid not starts with validator") + } + + @Test + fun shouldBeInvalidWithNotStartsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += NotStartsWithValidator( + prefix = "an", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "android" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using not starts with validator") + assertEquals("android is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithRegexContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexContainsValidator( + regex = """\d""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "24droid" } + + // THEN + assertEquals("24droid", manager.value) + assertTrue(manager.isValid, "should be valid using regex contains validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid regex contains validator") + } + + @Test + fun shouldBeInvalidWithRegexContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexContainsValidator( + regex = """\d""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "kotlin" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using regex contains validator") + assertEquals("kotlin is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithRegexMatchValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexMatchValidator( + regex = """\d{4}""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "2024" } + + // THEN + assertEquals("2024", manager.value) + assertTrue(manager.isValid, "should be valid using regex matches validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid regex matches validator") + } + + @Test + fun shouldBeInvalidWithRegexMatchValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexMatchValidator( + regex = """\d{4}""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "24" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using regex matches validator") + assertEquals("24 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithRegexNotContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexNotContainsValidator( + regex = """\d""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "android" } + + // THEN + assertEquals("android", manager.value) + assertTrue(manager.isValid, "should be valid using regex not contains validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid regex not contains validator") + } + + @Test + fun shouldBeInvalidWithRegexNotContainsValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexNotContainsValidator( + regex = """\d""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "24droid" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using regex not contains validator") + assertEquals("24droid is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithRegexNotMatchValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexNotMatchValidator( + regex = """\d{4}""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "24" } + + // THEN + assertEquals("24", manager.value) + assertTrue(manager.isValid, "should be valid using regex not matches validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid regex not matches validator") + } + + @Test + fun shouldBeInvalidWithRegexNotMatchValidator() { + // GIVEN + val manager = basicValueManager("") + manager += RegexNotMatchValidator( + regex = """\d{4}""".toRegex(), + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "2024" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using regex not matches validator") + assertEquals("2024 is invalid", manager.messages.first()) + } + + @Test + fun shouldBeValidWithStartsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += StartsWithValidator( + prefix = "an", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "android" } + + // THEN + assertEquals("android", manager.value) + assertTrue(manager.isValid, "should be valid using starts with validator") + assertTrue(manager.messages.isEmpty(), "should messages be empty having valid starts with validator") + } + + @Test + fun shouldBeInvalidWithStartsWithValidator() { + // GIVEN + val manager = basicValueManager("") + manager += StartsWithValidator( + prefix = "an", + message = { "$it is invalid" } + ) + + // WHEN + manager.update { "droid" } + + // THEN + assertEquals("", manager.value) + assertFalse(manager.isValid, "should be invalid using starts with validator") + assertEquals("droid is invalid", manager.messages.first()) + } +} \ No newline at end of file