diff options
Diffstat (limited to 'models-base/src/test')
10 files changed, 403 insertions, 565 deletions
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java index 062f6f953..8c74850d2 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java @@ -21,6 +21,7 @@ package org.onap.policy.models.base; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -111,9 +112,7 @@ public class PfConceptContainerTest { container.clean(); assertEquals(clonedContainer, container); - PfValidationResult result = new PfValidationResult(); - result = container.validate(result); - assertTrue(result.isOk()); + assertThat(container.validate("").getResult()).isNull(); assertEquals(0, container.compareTo(clonedContainer)); @@ -136,30 +135,30 @@ public class PfConceptContainerTest { final DummyPfConceptContainer container3 = container; assertThatThrownBy(() -> container3.validate(null)) - .hasMessageMatching("^resultIn is marked .*on.*ull but is null$"); + .hasMessageMatching("^fieldName is marked .*on.*ull but is null$"); DummyPfConceptContainer validateContainer = new DummyPfConceptContainer(); - assertFalse(validateContainer.validate(new PfValidationResult()).isOk()); + assertFalse(validateContainer.validate("").isValid()); validateContainer.setKey(new PfConceptKey("VCKey", VERSION0_0_1)); - assertTrue(validateContainer.validate(new PfValidationResult()).isOk()); + assertTrue(validateContainer.validate("").isValid()); validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(testConceptKey)); - assertTrue(validateContainer.validate(new PfValidationResult()).isOk()); + assertTrue(validateContainer.validate("").isValid()); validateContainer.getConceptMap().put(PfConceptKey.getNullKey(), new DummyPfConcept(PfConceptKey.getNullKey())); - assertFalse(validateContainer.validate(new PfValidationResult()).isOk()); + assertFalse(validateContainer.validate("").isValid()); validateContainer.getConceptMap().remove(PfConceptKey.getNullKey()); - assertTrue(validateContainer.validate(new PfValidationResult()).isOk()); + assertTrue(validateContainer.validate("").isValid()); validateContainer.getConceptMap().put(testConceptKey, null); - assertFalse(validateContainer.validate(new PfValidationResult()).isOk()); + assertFalse(validateContainer.validate("").isValid()); validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(testConceptKey)); - assertTrue(validateContainer.validate(new PfValidationResult()).isOk()); + assertTrue(validateContainer.validate("").isValid()); validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(conceptKey)); - assertFalse(validateContainer.validate(new PfValidationResult()).isOk()); + assertFalse(validateContainer.validate("").isValid()); validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(testConceptKey)); - assertTrue(validateContainer.validate(new PfValidationResult()).isOk()); + assertTrue(validateContainer.validate("").isValid()); assertEquals(conceptKey, container.get(conceptKey).getKey()); assertEquals(conceptKey, container.get(conceptKey.getName()).getKey()); diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java index 8b94a48c3..8d6b1b9f4 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java @@ -21,6 +21,7 @@ package org.onap.policy.models.base; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.Assert.assertEquals; @@ -35,6 +36,7 @@ import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import org.junit.Test; +import org.onap.policy.common.parameters.ValidationResult; import org.onap.policy.models.base.PfKey.Compatibility; import org.onap.policy.models.base.testconcepts.DummyPfKey; @@ -109,20 +111,13 @@ public class PfKeyImplTest { assertFalse(someKey1.isCompatible(someKey5)); assertFalse(someKey1.isCompatible(new DummyPfKey())); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey0.validate(new PfValidationResult()).getValidationResult()); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey1.validate(new PfValidationResult()).getValidationResult()); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey2.validate(new PfValidationResult()).getValidationResult()); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey3.validate(new PfValidationResult()).getValidationResult()); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey4.validate(new PfValidationResult()).getValidationResult()); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey5.validate(new PfValidationResult()).getValidationResult()); - assertEquals(PfValidationResult.ValidationResult.VALID, - someKey6.validate(new PfValidationResult()).getValidationResult()); + assertTrue(someKey0.validate("").isValid()); + assertTrue(someKey1.validate("").isValid()); + assertTrue(someKey2.validate("").isValid()); + assertTrue(someKey3.validate("").isValid()); + assertTrue(someKey4.validate("").isValid()); + assertTrue(someKey5.validate("").isValid()); + assertTrue(someKey6.validate("").isValid()); someKey0.clean(); assertNotNull(someKey0.toString()); @@ -179,22 +174,20 @@ public class PfKeyImplTest { Field nameField = testKey.getClass().getDeclaredField("name"); nameField.setAccessible(true); nameField.set(testKey, "Key Name"); - PfValidationResult validationResult = new PfValidationResult(); - testKey.validate(validationResult); + ValidationResult validationResult = testKey.validate(""); nameField.set(testKey, "TheKey"); nameField.setAccessible(false); - assertEquals("name invalid-parameter name with value Key Name " + "does not match regular expression " - + PfKey.NAME_REGEXP, validationResult.getMessageList().get(0).getMessage()); + assertThat(validationResult.getResult()).contains("\"name\"").doesNotContain("\"version\"") + .contains("does not match regular expression " + PfKey.NAME_REGEXP); Field versionField = testKey.getClass().getDeclaredField("version"); versionField.setAccessible(true); versionField.set(testKey, "Key Version"); - PfValidationResult validationResult2 = new PfValidationResult(); - testKey.validate(validationResult2); + ValidationResult validationResult2 = testKey.validate(""); versionField.set(testKey, VERSION001); versionField.setAccessible(false); - assertEquals("version invalid-parameter version with value Key Version " + "does not match regular expression " - + PfKey.VERSION_REGEXP, validationResult2.getMessageList().get(0).getMessage()); + assertThat(validationResult2.getResult()).doesNotContain("\"name\"").contains("\"version\"") + .contains("does not match regular expression " + PfKey.VERSION_REGEXP); } @Test diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java index f9ad889c7..d2aebdc43 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java @@ -62,9 +62,7 @@ public class PfKeyUseTest { keyUse.clean(); assertNotNull(keyUse); - PfValidationResult result = new PfValidationResult(); - result = keyUse.validate(result); - assertNotNull(result); + assertNotNull(keyUse.validate("")); assertNotEquals(0, keyUse.hashCode()); @@ -84,8 +82,7 @@ public class PfKeyUseTest { assertEquals(0, keyUse.compareTo(new PfKeyUse(key))); PfKeyUse keyUseNull = new PfKeyUse(PfConceptKey.getNullKey()); - PfValidationResult resultNull = new PfValidationResult(); - assertEquals(false, keyUseNull.validate(resultNull).isValid()); + assertEquals(false, keyUseNull.validate("").isValid()); assertThatThrownBy(() -> keyUse.setKey(null)).hasMessageMatching("^key is marked .*on.*ull but is null$"); @@ -93,7 +90,8 @@ public class PfKeyUseTest { assertThatThrownBy(() -> keyUse.isCompatible(null)).hasMessageMatching(OTHER_KEY_IS_NULL); - assertThatThrownBy(() -> keyUse.validate(null)).hasMessageMatching("^result is marked .*on.*ull but is null$"); + assertThatThrownBy(() -> keyUse.validate(null)) + .hasMessageMatching("^fieldName is marked .*on.*ull but is null$"); PfKeyUse testKeyUse = new PfKeyUse(new DummyPfConceptKeySub(new PfConceptKey())); assertEquals(testKeyUse, new PfKeyUse(testKeyUse)); diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java index 9e4e350a1..760231a7c 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java @@ -73,59 +73,59 @@ public class PfModelTest { public void testPfModelValidation() { PfConceptKey dpmKey = new PfConceptKey("modelKey", VERSION001); DummyPfModel dpm = new DummyPfModel(dpmKey); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); - assertThatThrownBy(() -> dpm.validate(null)).hasMessageMatching("^resultIn is marked .*on.*ull but is null$"); + assertThatThrownBy(() -> dpm.validate(null)).hasMessageMatching("^fieldName is marked .*on.*ull but is null$"); dpm.setKey(PfConceptKey.getNullKey()); - assertFalse(dpm.validate(new PfValidationResult()).isValid()); + assertFalse(dpm.validate("").isValid()); dpm.setKey(dpmKey); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); dpm.getKeyList().add(PfReferenceKey.getNullKey()); dpm.getKeyList().add(new PfKeyUse(PfReferenceKey.getNullKey())); - assertFalse(dpm.validate(new PfValidationResult()).isValid()); + assertFalse(dpm.validate("").isValid()); dpm.getKeyList().clear(); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfConceptKey goodCKey = new PfConceptKey("goodCKey", VERSION001); PfReferenceKey goodRKey = new PfReferenceKey(goodCKey, "goodLocalName"); dpm.getKeyList().add(goodCKey); dpm.getKeyList().add(goodRKey); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfConceptKey goodCKeyDup = new PfConceptKey(goodCKey); dpm.getKeyList().add(goodCKeyDup); - assertFalse(dpm.validate(new PfValidationResult()).isValid()); + assertFalse(dpm.validate("").isValid()); dpm.getKeyList().remove(goodCKeyDup); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfReferenceKey goodRKeyDup = new PfReferenceKey(goodRKey); dpm.getKeyList().add(goodRKeyDup); - assertFalse(dpm.validate(new PfValidationResult()).isValid()); + assertFalse(dpm.validate("").isValid()); dpm.getKeyList().remove(goodRKeyDup); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfKeyUse goodCKeyUse = new PfKeyUse(goodCKey); dpm.getKeyList().add(goodCKeyUse); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfKeyUse goodRKeyUse = new PfKeyUse(goodRKey); dpm.getKeyList().add(goodRKeyUse); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfConceptKey badCKey = new PfConceptKey("badCKey", VERSION001); PfKeyUse badCKeyUse = new PfKeyUse(badCKey); dpm.getKeyList().add(badCKeyUse); - assertFalse(dpm.validate(new PfValidationResult()).isValid()); + assertFalse(dpm.validate("").isValid()); dpm.getKeyList().remove(badCKeyUse); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); PfKeyUse badRKeyUse = new PfKeyUse(new PfReferenceKey(badCKey, "badLocalName")); dpm.getKeyList().add(badRKeyUse); - assertFalse(dpm.validate(new PfValidationResult()).isValid()); + assertFalse(dpm.validate("").isValid()); dpm.getKeyList().remove(badRKeyUse); - assertTrue(dpm.validate(new PfValidationResult()).isValid()); + assertTrue(dpm.validate("").isValid()); } } diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java index a27a5ddea..de328e9f2 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java @@ -21,6 +21,7 @@ package org.onap.policy.models.base; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -30,6 +31,7 @@ import static org.junit.Assert.assertTrue; import java.lang.reflect.Field; import org.junit.Test; +import org.onap.policy.common.parameters.ValidationResult; public class PfReferenceKeyTest { @@ -93,9 +95,7 @@ public class PfReferenceKeyTest { assertEquals(PfKey.Compatibility.DIFFERENT, testReferenceKey.getCompatibility(PfReferenceKey.getNullKey())); assertEquals(PfKey.Compatibility.IDENTICAL, testReferenceKey.getCompatibility(testReferenceKey)); - PfValidationResult result = new PfValidationResult(); - result = testReferenceKey.validate(result); - assertEquals(PfValidationResult.ValidationResult.VALID, result.getValidationResult()); + assertTrue(testReferenceKey.validate("").isValid()); testReferenceKey.clean(); @@ -139,49 +139,37 @@ public class PfReferenceKeyTest { Field parentNameField = testReferenceKey.getClass().getDeclaredField("parentKeyName"); parentNameField.setAccessible(true); parentNameField.set(testReferenceKey, "Parent Name"); - PfValidationResult validationResult = new PfValidationResult(); - testReferenceKey.validate(validationResult); + ValidationResult validationResult = testReferenceKey.validate(""); parentNameField.set(testReferenceKey, "ParentName"); parentNameField.setAccessible(false); - assertEquals( - "parentKeyName invalid-parameter parentKeyName with value Parent Name " - + "does not match regular expression " + PfKey.NAME_REGEXP, - validationResult.getMessageList().get(0).getMessage()); + assertThat(validationResult.getResult()).contains("\"parentKeyName\"") + .contains("does not match regular expression " + PfKey.NAME_REGEXP); Field parentVersionField = testReferenceKey.getClass().getDeclaredField("parentKeyVersion"); parentVersionField.setAccessible(true); parentVersionField.set(testReferenceKey, "Parent Version"); - PfValidationResult validationResult2 = new PfValidationResult(); - testReferenceKey.validate(validationResult2); + ValidationResult validationResult2 = testReferenceKey.validate(""); parentVersionField.set(testReferenceKey, VERSION001); parentVersionField.setAccessible(false); - assertEquals( - "parentKeyVersion invalid-parameter parentKeyVersion with value Parent Version " - + "does not match regular expression " + PfKey.VERSION_REGEXP, - validationResult2.getMessageList().get(0).getMessage()); + assertThat(validationResult2.getResult()).contains("\"parentKeyVersion\"") + .contains("does not match regular expression " + PfKey.VERSION_REGEXP); Field parentLocalNameField = testReferenceKey.getClass().getDeclaredField("parentLocalName"); parentLocalNameField.setAccessible(true); parentLocalNameField.set(testReferenceKey, "Parent Local Name"); - PfValidationResult validationResult3 = new PfValidationResult(); - testReferenceKey.validate(validationResult3); + ValidationResult validationResult3 = testReferenceKey.validate(""); parentLocalNameField.set(testReferenceKey, PARENT_LOCAL_NAME); parentLocalNameField.setAccessible(false); - assertEquals( - "parentLocalName invalid-parameter parentLocalName with value " - + "Parent Local Name does not match regular expression [A-Za-z0-9\\-_\\.]+|^$", - validationResult3.getMessageList().get(0).getMessage()); + assertThat(validationResult3.getResult()).contains("\"parentLocalName\"") + .contains("does not match regular expression [A-Za-z0-9\\-_\\.]+|^$"); Field localNameField = testReferenceKey.getClass().getDeclaredField("localName"); localNameField.setAccessible(true); localNameField.set(testReferenceKey, "Local Name"); - PfValidationResult validationResult4 = new PfValidationResult(); - testReferenceKey.validate(validationResult4); + ValidationResult validationResult4 = testReferenceKey.validate(""); localNameField.set(testReferenceKey, LOCAL_NAME); localNameField.setAccessible(false); - assertEquals( - "localName invalid-parameter localName with value Local Name " - + "does not match regular expression [A-Za-z0-9\\-_\\.]+|^$", - validationResult4.getMessageList().get(0).getMessage()); + assertThat(validationResult4.getResult()).contains("\"localName\"") + .contains("does not match regular expression [A-Za-z0-9\\-_\\.]+|^$"); } } diff --git a/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java b/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java index 5d1367028..8534d82a6 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java @@ -1,9 +1,8 @@ -/* +/*- * ============LICENSE_START======================================================= - * ONAP Policy Models + * ONAP * ================================================================================ - * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved. - * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,424 +20,426 @@ package org.onap.policy.models.base; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; -import java.util.Arrays; -import java.util.Iterator; -import java.util.LinkedHashMap; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.Map; -import org.junit.Before; +import java.util.function.BiFunction; +import lombok.AllArgsConstructor; +import lombok.NonNull; import org.junit.Test; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ObjectValidationResult; +import org.onap.policy.common.parameters.ValidationResult; +import org.onap.policy.common.parameters.ValidationStatus; +import org.onap.policy.common.utils.coder.CoderException; +import org.onap.policy.common.utils.coder.StandardCoder; public class ValidatedTest { - private static final String COLLECTION_TEXT = "collection"; - private static final String ERROR_MESSAGE = "error message"; - private static final String COLLECTION_FIELD = "coll"; - private static final String VALID_VALUE = "abc123"; - private static final String PROPS_FIELD = "props"; - private static final String MY_NAME = "my.name"; - private static final String VALID_FIELD = "validField"; - private static final String INVALID_FIELD = "invalidField"; - private static final String NULL_FIELD = "nullField"; - private static final String WORD_PAT = "\\w*"; - private static final String MY_TO_STRING = "[some text]"; - private static final String VERSION = "1.2.3"; - - private Validated validated; - - @Before - public void setUp() { - validated = new Validated(); + private static final @NonNull String MY_FIELD = "myField"; + private static final @NonNull String Q_KEY = "\"" + Validated.KEY_TOKEN + "\""; + private static final @NonNull String Q_VALUE = "\"" + Validated.VALUE_TOKEN + "\""; + private static final String NOT_SAME = "not same"; + private static final String TEXT = "some text"; + private static final String OTHER = "other text"; + private static final String NAME = "myKey"; + private static final String VERSION = "1.0.0"; + private static final String BLANKS = "\t \n"; + + @Test + public void testAddResult() { + BeanValidationResult result = new BeanValidationResult("", this); + Validated.addResult(result, MY_FIELD, TEXT, "some message"); + assertThat(result.getResult()).contains(MY_FIELD).contains(TEXT).contains("some message"); + + assertThatThrownBy(() -> Validated.addResult(null, MY_FIELD, TEXT, OTHER)) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> Validated.addResult(result, null, TEXT, OTHER)) + .isInstanceOf(NullPointerException.class); + + assertThatCode(() -> Validated.addResult(result, MY_FIELD, null, OTHER)).doesNotThrowAnyException(); + + assertThatThrownBy(() -> Validated.addResult(result, MY_FIELD, TEXT, null)) + .isInstanceOf(NullPointerException.class); } @Test - public void testValidate() { - assertThatThrownBy(() -> validated.validate(null)).isInstanceOf(NullPointerException.class); + public void testMakeNullResult() { + ValidationResult rnull = Validated.makeNullResult(MY_FIELD, TEXT); + assertEquals(MY_FIELD, rnull.getName()); + assertThat(rnull.getResult()).contains(MY_FIELD).contains(TEXT).contains(Validated.IS_NULL); + assertFalse(rnull.isValid()); + + assertThatThrownBy(() -> Validated.makeNullResult(null, TEXT)).isInstanceOf(NullPointerException.class); - PfValidationResult result = new PfValidationResult(); - assertSame(result, validated.validate(result)); - assertTrue(result.isValid()); - assertEquals(0, result.getMessageList().size()); + assertThatCode(() -> Validated.makeNullResult(MY_FIELD, null)).doesNotThrowAnyException(); } @Test - public void testValidateNotNull() { - PfValidationResult result = new PfValidationResult(); + public void testValidateOptional() { + BeanValidationResult result = new BeanValidationResult("", this); + Validated.validateOptional(result, MY_FIELD, null); + assertTrue(result.isClean()); - final PfValidationResult result2 = result; - assertThatThrownBy(() -> validated.validateNotNull(null, VALID_FIELD, VALID_VALUE, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateNotNull(this, null, VALID_VALUE, result2)) + Validated.validateOptional(result, MY_FIELD, new MyString(TEXT)); + assertTrue(result.isClean()); + + Validated.validateOptional(result, MY_FIELD, new MyString(OTHER)); + assertThat(result.getResult()).contains(MY_FIELD).contains(OTHER).contains(NOT_SAME); + + assertThatThrownBy(() -> Validated.validateOptional(null, MY_FIELD, new MyString(TEXT))) .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateNotNull(this, VALID_FIELD, VALID_VALUE, null)) + + assertThatThrownBy(() -> Validated.validateOptional(result, null, new MyString(TEXT))) .isInstanceOf(NullPointerException.class); - // null text - result = validated.validateNotNull(this, NULL_FIELD, null, result); + assertThatCode(() -> Validated.validateOptional(result, MY_FIELD, null)).doesNotThrowAnyException(); + } + + @Test + public void testValidateNotNull() { + assertThat(Validated.validateNotNull(MY_FIELD, TEXT)).isNull(); - // invalid text - result = validated.validateNotNull(this, INVALID_FIELD, "!!!", result); + assertThat(Validated.validateNotNull(MY_FIELD, null).getResult()).contains(MY_FIELD) + .contains(Validated.IS_NULL); - // valid text - result = validated.validateNotNull(this, VALID_FIELD, VALID_VALUE, result); + // should invoke the value's validate() method, which should return success + assertThat(Validated.validateNotNull(MY_FIELD, new MyString(TEXT))).isNull(); - // different value - result = validated.validateNotNull(this, VALID_FIELD, Integer.valueOf(10), result); + // should invoke the value's validate() method, which should return failure + assertThat(Validated.validateNotNull(MY_FIELD, new MyString(OTHER)).getResult()).contains(MY_FIELD) + .contains(NOT_SAME); - assertFalse(result.isValid()); - assertEquals(1, result.getMessageList().size()); + assertThatThrownBy(() -> Validated.validateNotNull(null, TEXT)).isInstanceOf(NullPointerException.class); - // check result for null text - PfValidationMessage msg = result.getMessageList().get(0); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("nullField invalid-null")); + assertThatCode(() -> Validated.validateNotNull(MY_FIELD, null)).doesNotThrowAnyException(); } @Test - public void testValidateNotNullConceptKey() { - PfValidationResult result = new PfValidationResult(); - - // null key - PfConceptKey key = new PfConceptKey(); - key.setVersion(VERSION); - result = validated.validateNotNull(key, result); - - // null value - key = new PfConceptKey(); - key.setName(MY_NAME); - result = validated.validateNotNull(key, result); - - // both null - key = new PfConceptKey(); - result = validated.validateNotNull(key, result); - - assertFalse(result.isValid()); - assertEquals(4, result.getMessageList().size()); - - // valid key & value - key = new PfConceptKey(); - key.setName(MY_NAME); - key.setVersion(VERSION); - result = validated.validateNotNull(key, result); - - // no change - assertFalse(result.isValid()); - assertEquals(4, result.getMessageList().size()); - - Iterator<PfValidationMessage> it = result.getMessageList().iterator(); - - // check null key - PfValidationMessage msg = it.next(); - assertEquals(PfConceptKey.class.getName(), msg.getObservedClass()); - assertTrue(msg.getMessage().contains("name invalid-null")); - - // check null value - msg = it.next(); - assertEquals(PfConceptKey.class.getName(), msg.getObservedClass()); - assertTrue(msg.getMessage().contains("version invalid-null")); - - // check both null - msg = it.next(); - assertEquals(PfConceptKey.class.getName(), msg.getObservedClass()); - assertTrue(msg.getMessage().contains("name invalid-null")); - assertTrue(it.next().getMessage().contains("version invalid-null")); - - PfValidationResult pfValidationResult = new PfValidationResult(); - final PfConceptKey key2 = key; - assertThatThrownBy(() -> validated.validateNotNull(key2, null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateNotNull(null, pfValidationResult)) + public void testValidateNotBlank() { + assertThat(Validated.validateNotBlank(MY_FIELD, TEXT, false)).isNull(); + assertThat(Validated.validateNotBlank(MY_FIELD, TEXT, true)).isNull(); + + assertThat(Validated.validateNotBlank(MY_FIELD, null, false)).isNull(); + assertThat(Validated.validateNotBlank(MY_FIELD, null, true).getResult()).contains(MY_FIELD) + .contains(Validated.IS_BLANK); + + assertThat(Validated.validateNotBlank(MY_FIELD, "", false).getResult()).contains(MY_FIELD) + .contains(Validated.IS_BLANK); + assertThat(Validated.validateNotBlank(MY_FIELD, "", true).getResult()).contains(MY_FIELD) + .contains(Validated.IS_BLANK); + + assertThatThrownBy(() -> Validated.validateNotBlank(null, TEXT, false)) .isInstanceOf(NullPointerException.class); + + assertThatCode(() -> Validated.validateNotBlank(MY_FIELD, null, false)).doesNotThrowAnyException(); } @Test - public void testValidateText() { - PfValidationResult result = new PfValidationResult(); + public void testValidateRegex() { + assertThat(Validated.validateRegex(MY_FIELD, "hello", ".*ll.*")).isNull(); - final PfValidationResult result2 = result; - assertThatThrownBy(() -> validated.validateText(null, VALID_FIELD, VALID_VALUE, WORD_PAT, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateText(this, null, VALID_VALUE, WORD_PAT, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateText(this, VALID_FIELD, VALID_VALUE, null, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateText(this, VALID_FIELD, VALID_VALUE, WORD_PAT, null)) - .isInstanceOf(NullPointerException.class); + assertThat(Validated.validateRegex(MY_FIELD, "hello", "[x-z]").getResult()).contains(MY_FIELD).contains("hello") + .contains("does not match regular expression [x-z]"); - // null text - result = validated.validateText(this, NULL_FIELD, null, WORD_PAT, result); + assertThatThrownBy(() -> Validated.validateRegex(null, "hello", "ll")).isInstanceOf(NullPointerException.class); - // invalid text - result = validated.validateText(this, INVALID_FIELD, "!!!", WORD_PAT, result); + assertThatCode(() -> Validated.validateRegex(MY_FIELD, null, "ll")).doesNotThrowAnyException(); - // valid text - result = validated.validateText(this, VALID_FIELD, VALID_VALUE, WORD_PAT, result); + assertThatThrownBy(() -> Validated.validateRegex(MY_FIELD, "hello", null)) + .isInstanceOf(NullPointerException.class); + } - assertFalse(result.isValid()); - assertEquals(1, result.getMessageList().size()); + @Test + public void testValidateKeyNotNull() throws CoderException { + assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey(NAME, VERSION)).getResult()).isNull(); + assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey(NAME, PfConceptKey.NULL_KEY_VERSION)) + .getResult()).isNull(); + assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey(PfConceptKey.NULL_KEY_NAME, VERSION)) + .getResult()).isNull(); + + // key is null + assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey()).getResult()).contains(MY_FIELD) + .doesNotContain("\"name\"").doesNotContain("\"version\"").contains(Validated.IS_A_NULL_KEY); + + /* + * Key is not null, but key.validate() should fail due to an invalid version. + * Note: have to create the key by decoding from json, as the class will prevent + * an invalid version from being assigned. + */ + PfConceptKey key = new StandardCoder().decode("{'name':'myKey','version':'bogus'}".replace('\'', '"'), + PfConceptKey.class); + assertThat(Validated.validateKeyNotNull(MY_FIELD, key).getResult()).contains(MY_FIELD).contains("version") + .contains("does not match regular expression"); + + // null parameter tests + assertThatThrownBy(() -> Validated.validateKeyNotNull(null, new PfConceptKey())) + .isInstanceOf(NullPointerException.class); - // check result for invalid text - PfValidationMessage msg = result.getMessageList().get(0); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("invalidField invalid-parameter invalidField")); + assertThatCode(() -> Validated.validateKeyNotNull(MY_FIELD, null)).doesNotThrowAnyException(); } @Test - public void testValidatePropertiesNotNull() { - PfValidationResult result = new PfValidationResult(); - result = validated.validatePropertiesNotNull(this, "properties", null, result); - assertTrue(result.isValid()); - assertEquals(0, result.getMessageList().size()); + public void testValidateKeyVersionNotNull() { + assertThat(Validated.validateKeyVersionNotNull(MY_FIELD, null)).isNull(); - Map<String, Integer> map = new LinkedHashMap<>(); + assertThat(Validated.validateKeyVersionNotNull(MY_FIELD, new PfConceptKey(NAME, VERSION))).isNull(); - // null key - map.put(null, 10); + assertThat(Validated.validateKeyVersionNotNull(MY_FIELD, new PfConceptKey(NAME, PfConceptKey.NULL_KEY_VERSION)) + .getResult()).contains(MY_FIELD).contains("version").contains(Validated.IS_NULL); - // null value - map.put("abc", null); + assertThatThrownBy(() -> Validated.validateKeyVersionNotNull(null, new PfConceptKey())) + .isInstanceOf(NullPointerException.class); - // valid key & value - map.put("def", 11); + assertThatCode(() -> Validated.validateKeyVersionNotNull(MY_FIELD, null)).doesNotThrowAnyException(); + } + @Test + public void testValidateMinIntIntegerBoolean_testValidateMinStringIntegerIntIntegerBoolean() { + /* + * No "special" value, don't check the reference. + */ + BiFunction<String, Integer, ValidationResult> func = Validated.validateMin(10, null, false); + assertThat(func.apply(MY_FIELD, null)).isNull(); - result = validated.validatePropertiesNotNull(this, PROPS_FIELD, map, result); + // exact match + assertThat(func.apply(MY_FIELD, 10)).isNull(); - assertFalse(result.isValid()); - assertEquals(2, result.getMessageList().size()); + assertThat(func.apply(MY_FIELD, 20)).isNull(); - Iterator<PfValidationMessage> it = result.getMessageList().iterator(); + assertThat(func.apply(MY_FIELD, 9).getResult()).contains(MY_FIELD).contains("9") + .contains("is below the minimum value: 10"); - // check null key - PfValidationMessage msg = it.next(); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("props.null invalid-null")); + /* + * "special" value, don't check the reference. + */ + func = Validated.validateMin(10, 7, false); + assertThat(func.apply(MY_FIELD, null)).isNull(); - // check null value - msg = it.next(); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("props.abc invalid-null")); + // exact match + assertThat(func.apply(MY_FIELD, 10)).isNull(); - final PfValidationResult result2 = result; - assertThatThrownBy(() -> validated.validatePropertiesNotNull(null, PROPS_FIELD, map, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validatePropertiesNotNull(this, null, map, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validatePropertiesNotNull(this, PROPS_FIELD, map, null)) - .isInstanceOf(NullPointerException.class); - } + assertThat(func.apply(MY_FIELD, 20)).isNull(); - @Test - public void testValidateCollectionNotNull() { - PfValidationResult result = new PfValidationResult(); - result = validated.validateCollectionNotNull(this, COLLECTION_TEXT, null, result); - assertTrue(result.isValid()); - assertEquals(0, result.getMessageList().size()); + // special value - should be ok + assertThat(func.apply(MY_FIELD, 7)).isNull(); - final List<String> lst = Arrays.asList("abc", null, "def", null); + assertThat(func.apply(MY_FIELD, 9).getResult()).contains(MY_FIELD).contains("9") + .contains("is below the minimum value: 10"); - result = validated.validateCollectionNotNull(this, COLLECTION_FIELD, lst, result); + /* + * Check the reference (i.e., generate an error if the value is null). + */ + func = Validated.validateMin(10, null, true); + assertThat(func.apply(MY_FIELD, null).getResult()).contains(MY_FIELD).contains(Validated.IS_NULL); - assertFalse(result.isValid()); - assertEquals(2, result.getMessageList().size()); + // exact match + assertThat(func.apply(MY_FIELD, 10)).isNull(); - Iterator<PfValidationMessage> it = result.getMessageList().iterator(); + assertThat(func.apply(MY_FIELD, 20)).isNull(); - // check first item - PfValidationMessage msg = it.next(); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("coll.1 invalid-null")); + assertThat(func.apply(MY_FIELD, 9).getResult()).contains(MY_FIELD).contains("9") + .contains("is below the minimum value: 10"); - // check null value - msg = it.next(); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("coll.3 invalid-null")); - final PfValidationResult result2 = result; - assertThatThrownBy(() -> validated.validateCollectionNotNull(null, COLLECTION_FIELD, lst, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateCollectionNotNull(this, null, lst, result2)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateCollectionNotNull(this, COLLECTION_FIELD, lst, null)) - .isInstanceOf(NullPointerException.class); + BiFunction<String, Integer, ValidationResult> func2 = func; + assertThatThrownBy(() -> func2.apply(null, 30)).isInstanceOf(NullPointerException.class); + + assertThatCode(() -> func2.apply(MY_FIELD, null)).doesNotThrowAnyException(); } @Test - public void testValidateCollection() { - PfValidationResult result = new PfValidationResult(); - result = validated.validateCollection(this, COLLECTION_TEXT, null, result); - assertTrue(result.isValid()); - assertEquals(0, result.getMessageList().size()); - - List<MyValid> lst = Arrays.asList(new MyValid(0, false), new MyValid(1, true), null, new MyValid(2, false), - new MyValid(3, true)); - result = validated.validateCollection(this, COLLECTION_FIELD, lst, result); - - assertFalse(result.isValid()); - assertEquals(2, result.getMessageList().size()); - - Iterator<PfValidationMessage> it = result.getMessageList().iterator(); - - // check first item - PfValidationMessage msg = it.next(); - assertEquals(MyValid.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("index.0 invalid-wrong value")); - - // check null value - msg = it.next(); - assertEquals(MyValid.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("index.2 invalid-wrong value")); - - final PfValidationResult result2 = result; - assertThatThrownBy(() -> validated.validateCollection(null, COLLECTION_FIELD, lst, result2)) + public void testValidateList() { + BeanValidationResult result = new BeanValidationResult("", this); + Validated.validateList(result, MY_FIELD, null, Validated::validateNotNull); + assertThat(result.getResult()).isNull(); + + result = new BeanValidationResult("", this); + Validated.validateList(result, MY_FIELD, List.of(TEXT, OTHER), Validated::validateNotNull); + assertThat(result.getResult()).isNull(); + + List<String> list = new ArrayList<>(); + list.add(TEXT); + list.add(null); + list.add(OTHER); + list.add(null); + result = new BeanValidationResult("", this); + Validated.validateList(result, MY_FIELD, list, Validated::validateNotNull); + assertThat(result.getResult()).doesNotContain("0").contains("1").doesNotContain("2").contains("3") + .contains(Validated.IS_NULL); + + BeanValidationResult result2 = result; + assertThatThrownBy(() -> Validated.validateList(null, MY_FIELD, List.of(), Validated::validateNotNull)) .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateCollection(this, null, lst, result2)) + + assertThatThrownBy(() -> Validated.validateList(result2, null, List.of(), Validated::validateNotNull)) .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateCollection(this, COLLECTION_FIELD, lst, null)) + + assertThatCode(() -> Validated.validateList(result2, MY_FIELD, null, Validated::validateNotNull)) + .doesNotThrowAnyException(); + + assertThatThrownBy(() -> Validated.validateList(result2, MY_FIELD, List.of(), null)) .isInstanceOf(NullPointerException.class); } @Test - public void testValidateConceptCollection() { - PfValidationResult result = new PfValidationResult(); - result = validated.validateConceptCollection(this, COLLECTION_TEXT, null, result); - assertTrue(result.isValid()); - assertEquals(0, result.getMessageList().size()); - - List<MyConcept> lst = Arrays.asList(new MyConcept(0, false), new MyConcept(1, true), null, - new MyConcept(2, false), new MyConcept(3, true)); - result = validated.validateConceptCollection(this, COLLECTION_FIELD, lst, result); - - assertFalse(result.isValid()); - assertEquals(2, result.getMessageList().size()); - - Iterator<PfValidationMessage> it = result.getMessageList().iterator(); - - // check first item - PfValidationMessage msg = it.next(); - assertEquals(MyConcept.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("index.0 invalid-wrong value")); - - // check null value - msg = it.next(); - assertEquals(MyConcept.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("index.2 invalid-wrong value")); - - final PfValidationResult result2 = result; - assertThatThrownBy(() -> validated.validateConceptCollection(null, COLLECTION_FIELD, lst, result2)) + public void testValidateMap() { + BeanValidationResult result = new BeanValidationResult("", this); + Validated.validateMap(result, MY_FIELD, null, Validated::validateEntryNotBlankNotBlank); + assertThat(result.getResult()).isNull(); + + result = new BeanValidationResult("", this); + Validated.validateMap(result, MY_FIELD, Map.of("abc", TEXT, "def", OTHER), + Validated::validateEntryNotBlankNotBlank); + assertThat(result.getResult()).isNull(); + + // invalid values + Map<String, String> map = new HashMap<>(); + map.put("ghi", TEXT); + map.put("jkl", ""); + map.put("mno", OTHER); + map.put("pqr", ""); + result = new BeanValidationResult("", this); + Validated.validateMap(result, MY_FIELD, map, Validated::validateEntryNotBlankNotBlank); + assertThat(result.getResult()).doesNotContain("abc").contains("jkl").doesNotContain("mno").contains("pqr") + .contains(Q_VALUE).doesNotContain(Q_KEY).contains(Validated.IS_BLANK); + + // invalid keys + map = new HashMap<>(); + map.put("stu", TEXT); + map.put("", TEXT); + map.put("vwx", OTHER); + map.put(null, OTHER); + result = new BeanValidationResult("", this); + Validated.validateMap(result, MY_FIELD, map, Validated::validateEntryNotBlankNotBlank); + assertThat(result.getResult()).doesNotContain("stu").contains("\"\"").doesNotContain("vwx").contains("null") + .contains(Q_KEY).doesNotContain(Q_VALUE).contains(Validated.IS_BLANK); + + BeanValidationResult result2 = result; + Map<String, String> map2 = map; + assertThatThrownBy(() -> Validated.validateMap(null, MY_FIELD, map2, Validated::validateEntryNotBlankNotBlank)) .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateConceptCollection(this, null, lst, result2)) + + assertThatThrownBy(() -> Validated.validateMap(result2, null, map2, Validated::validateEntryNotBlankNotBlank)) .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.validateConceptCollection(this, COLLECTION_FIELD, lst, null)) + + assertThatCode(() -> Validated.validateMap(result2, MY_FIELD, null, Validated::validateEntryNotBlankNotBlank)) + .doesNotThrowAnyException(); + + assertThatThrownBy(() -> Validated.validateMap(result2, MY_FIELD, map2, null)) .isInstanceOf(NullPointerException.class); } @Test - public void testAddError() { - final PfValidationResult result = new PfValidationResult(); - final PfValidationResult result2 = result; + public void testValidateEntryNotBlankNotBlank() { + assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(TEXT, OTHER))).isNull(); - assertThatThrownBy(() -> validated.addError(null, VALID_FIELD, result2, ERROR_MESSAGE)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.addError(this, null, result2, ERROR_MESSAGE)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> validated.addError(this, VALID_FIELD, null, ERROR_MESSAGE)) - .isInstanceOf(NullPointerException.class); - - validated.addError(this, VALID_FIELD, result, "error-A"); - validated.addError(this, VALID_FIELD, result, null); - validated.addError(this, VALID_FIELD, result, "error-B"); + // try invalid values for the key + assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(null, OTHER)).getResult()).contains(Q_KEY) + .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE); - assertFalse(result.isValid()); - assertEquals(2, result.getMessageList().size()); + assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(BLANKS, OTHER)).getResult()).contains(Q_KEY) + .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE); - Iterator<PfValidationMessage> it = result.getMessageList().iterator(); + // try invalid values for the value + assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(TEXT, null)).getResult()).contains(Q_VALUE) + .contains(Validated.IS_BLANK).doesNotContain(Q_KEY); - PfValidationMessage msg = it.next(); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("validField invalid-error-A")); + assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(TEXT, BLANKS)).getResult()).contains(Q_VALUE) + .contains(Validated.IS_BLANK).doesNotContain(Q_KEY); - msg = it.next(); - assertEquals(ValidatedTest.class.getName(), msg.getObservedClass()); - assertEquals(MY_TO_STRING, msg.getObservedKey().toString()); - assertTrue(msg.getMessage().contains("validField invalid-error-B")); + // both invalid + assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(BLANKS, BLANKS)).getResult()).contains(Q_KEY) + .contains(Q_VALUE); } @Test - public void testMakeKey() { - assertThatThrownBy(() -> validated.makeKey(null)).isInstanceOf(NullPointerException.class); + public void testValidateEntryNotBlankNotNull() { + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, OTHER))).isNull(); - PfKey key = validated.makeKey(this); - assertEquals(MY_TO_STRING, key.toString()); - } + // try invalid values for the key + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(null, OTHER)).getResult()).contains(Q_KEY) + .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE); + + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(BLANKS, OTHER)).getResult()).contains(Q_KEY) + .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE); - @Override - public String toString() { - return MY_TO_STRING; + // try invalid values for the value + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, null)).getResult()).contains(Q_VALUE) + .contains(Validated.IS_NULL).doesNotContain(Q_KEY); + + // blanks should have no impact for the value + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, BLANKS))).isNull(); + + // both invalid + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(BLANKS, null)).getResult()).contains(Q_KEY) + .contains(Q_VALUE); } - private static class MyValid extends Validated { - private boolean valid; - private int index; + @Test + public void testValidateEntryValueNotNull() { + assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, OTHER))).isNull(); - public MyValid(int index, boolean valid) { - this.index = index; - this.valid = valid; - } + // blanks should have no impact + assertThat(Validated.validateEntryValueNotNull(makeEntry(BLANKS, OTHER))).isNull(); + assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, BLANKS))).isNull(); - @Override - public PfValidationResult validate(PfValidationResult result) { - if (!valid) { - this.addError(this, "index." + index, result, "wrong value"); - } + assertThat(Validated.validateEntryValueNotNull(makeEntry(null, OTHER)).getResult()).contains(Q_KEY) + .contains(Validated.IS_NULL).doesNotContain(Q_VALUE); - return result; - } + assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, null)).getResult()).contains(Q_VALUE) + .contains(Validated.IS_NULL).doesNotContain(Q_KEY); - @Override - public String toString() { - return MY_TO_STRING; - } + // should invoke the value's validate() method, which should return success + assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, new MyString(TEXT)))).isNull(); + + // should invoke the value's validate() method, which should return failure + assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, new MyString(OTHER))).getResult()) + .contains(Q_VALUE).contains(NOT_SAME).doesNotContain(Q_KEY); + + // both invalid + assertThat(Validated.validateEntryValueNotNull(makeEntry(null, null)).getResult()).contains(Q_KEY) + .contains(Q_VALUE); } - private static class MyConcept extends PfConceptKey { - private static final long serialVersionUID = 1L; + @Test + public void testGetKeyId() { + // not a key field - should just use the given value + BeanValidationResult result = new BeanValidationResult("", this); + Validated.addResult(result, MY_FIELD, TEXT, "some message"); + assertThat(result.getResult()).contains(MY_FIELD).contains(TEXT).contains("some message"); + + // repeat with a key field - should use the key's ID + result = new BeanValidationResult("", this); + Validated.addResult(result, MY_FIELD, new PfConceptKey(NAME, VERSION), "some message"); + assertThat(result.getResult()).contains(MY_FIELD).contains("myKey:1.0.0").contains("some message"); + } - private boolean valid; - private int index; + private <V> Map.Entry<String, V> makeEntry(String key, V value) { + Map<String, V> map = new HashMap<>(); + map.put(key, value); + return map.entrySet().iterator().next(); + } - public MyConcept(int index, boolean valid) { - this.index = index; - this.valid = valid; - } + @AllArgsConstructor + private static class MyString extends Validated { + private final String text; @Override - public PfValidationResult validate(PfValidationResult result) { - if (!valid) { - new Validated().addError(this, "index." + index, result, "wrong value"); + public ValidationResult validate(String fieldName) { + if (TEXT.equals(text)) { + return null; } - return result; - } - - @Override - public String toString() { - return MY_TO_STRING; + return new ObjectValidationResult(fieldName, text, ValidationStatus.INVALID, NOT_SAME); } } } diff --git a/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java b/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java deleted file mode 100644 index 6030d2ab9..000000000 --- a/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java +++ /dev/null @@ -1,133 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * Copyright (C) 2019-2020 Nordix Foundation. - * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * SPDX-License-Identifier: Apache-2.0 - * ============LICENSE_END========================================================= - */ - -package org.onap.policy.models.base; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -import org.junit.Test; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; - -public class ValidationTest { - - private static final String HELLO = "hello"; - private static final String SOME_MESSAGE = "Some message"; - - @Test - public void testValidation1() { - PfValidationResult result = new PfValidationResult(); - PfConceptKey pfKeyey = new PfConceptKey("PK", "0.0.1"); - result = pfKeyey.validate(result); - - assertNotNull(result); - assertTrue(result.isOk()); - assertTrue(result.isValid()); - assertEquals(PfValidationResult.ValidationResult.VALID, result.getValidationResult()); - assertNotNull(result.getMessageList()); - - PfValidationMessage vmess0 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.VALID, SOME_MESSAGE); - result.addValidationMessage(vmess0); - - assertTrue(result.isOk()); - assertTrue(result.isValid()); - assertEquals(PfValidationResult.ValidationResult.VALID, result.getValidationResult()); - assertNotNull(result.getMessageList()); - assertNotNull(HELLO, result.toString()); - - PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.OBSERVATION, SOME_MESSAGE); - result.addValidationMessage(vmess1); - - assertTrue(result.isOk()); - assertTrue(result.isValid()); - assertEquals(PfValidationResult.ValidationResult.OBSERVATION, result.getValidationResult()); - assertNotNull(result.getMessageList()); - assertNotNull(HELLO, result.toString()); - } - - - @Test - public void testValidation2() { - PfValidationResult result = new PfValidationResult(); - - PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.WARNING, SOME_MESSAGE); - result.addValidationMessage(vmess2); - - assertFalse(result.isOk()); - assertTrue(result.isValid()); - assertEquals(PfValidationResult.ValidationResult.WARNING, result.getValidationResult()); - assertNotNull(result.getMessageList()); - assertNotNull(HELLO, result.toString()); - - PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.INVALID, SOME_MESSAGE); - result.addValidationMessage(vmess3); - - assertFalse(result.isOk()); - assertFalse(result.isValid()); - assertEquals(PfValidationResult.ValidationResult.INVALID, result.getValidationResult()); - assertNotNull(result.getMessageList()); - assertNotNull(HELLO, result.toString()); - - assertEquals(PfValidationResult.ValidationResult.INVALID, result.getMessageList().get(1).getValidationResult()); - assertEquals(SOME_MESSAGE, result.getMessageList().get(1).getMessage()); - assertEquals(PfConceptKey.class.getName(), result.getMessageList().get(1).getObservedClass()); - assertEquals(PfConceptKey.getNullKey(), result.getMessageList().get(1).getObservedKey()); - } - - @Test - public void testValidationAppend() { - PfValidationResult result = new PfValidationResult(); - - PfValidationResult result2 = new PfValidationResult(); - PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.OBSERVATION, "Message 1"); - result2.addValidationMessage(vmess1); - - result.append(result2); - assertEquals(1, result.getMessageList().size()); - assertEquals(ValidationResult.OBSERVATION, result.getValidationResult()); - - PfValidationResult result3 = new PfValidationResult(); - PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.WARNING, "Message 2"); - result3.addValidationMessage(vmess2); - result.append(result3); - assertEquals(2, result.getMessageList().size()); - assertEquals(ValidationResult.WARNING, result.getValidationResult()); - - PfValidationResult result4 = new PfValidationResult(); - PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.INVALID, "Message 3"); - PfValidationMessage vmess4 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.VALID, "Message 4"); - result4.addValidationMessage(vmess3); - result4.addValidationMessage(vmess4); - result.append(result4); - assertEquals(4, result.getMessageList().size()); - assertEquals(ValidationResult.INVALID, result.getValidationResult()); - } -} diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java index be398b95f..67a450702 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java +++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java @@ -1,7 +1,7 @@ /*- * ============LICENSE_START======================================================= * Copyright (C) 2019 Nordix Foundation. - * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,13 +27,12 @@ import lombok.Data; import lombok.EqualsAndHashCode; import lombok.NonNull; import org.apache.commons.lang3.ObjectUtils; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ValidationResult; import org.onap.policy.models.base.PfAuthorative; import org.onap.policy.models.base.PfConcept; import org.onap.policy.models.base.PfConceptKey; import org.onap.policy.models.base.PfKey; -import org.onap.policy.models.base.PfValidationMessage; -import org.onap.policy.models.base.PfValidationResult; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; @Data @EqualsAndHashCode(callSuper = false) @@ -102,20 +101,11 @@ public class DummyPfConcept extends PfConcept implements PfAuthorative<DummyAuth } @Override - public PfValidationResult validate(PfValidationResult resultIn) { - PfValidationResult result = resultIn; + public ValidationResult validate(@NonNull String fieldName) { + BeanValidationResult result = new BeanValidationResult(fieldName, this); - if (key.isNullKey()) { - result.addValidationMessage( - new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key")); - } - - result = key.validate(result); - - if (description != null && description.trim().length() == 0) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "property description may not be blank")); - } + result.addResult(validateKeyNotNull("key", key)); + result.addResult(validateNotBlank("description", description, false)); return result; } diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java index 81ebb6e59..5a5891ad6 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java +++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java @@ -1,7 +1,7 @@ /*- * ============LICENSE_START======================================================= * Copyright (C) 2019 Nordix Foundation. - * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,9 +24,9 @@ package org.onap.policy.models.base.testconcepts; import java.util.Arrays; import java.util.List; import lombok.NonNull; +import org.onap.policy.common.parameters.ValidationResult; import org.onap.policy.models.base.PfConcept; import org.onap.policy.models.base.PfKey; -import org.onap.policy.models.base.PfValidationResult; public class DummyPfKey extends PfKey { private static final long serialVersionUID = 1L; @@ -75,7 +75,7 @@ public class DummyPfKey extends PfKey { } @Override - public PfValidationResult validate(PfValidationResult result) { + public ValidationResult validate(@NonNull String fieldName) { return null; } diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java index 764b91b24..f828fba09 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java +++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java @@ -1,7 +1,7 @@ /*- * ============LICENSE_START======================================================= * Copyright (C) 2019 Nordix Foundation. - * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,12 +25,13 @@ import java.util.ArrayList; import java.util.List; import lombok.Data; import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.onap.policy.common.parameters.BeanValidationResult; import org.onap.policy.models.base.PfConcept; import org.onap.policy.models.base.PfConceptKey; import org.onap.policy.models.base.PfKey; import org.onap.policy.models.base.PfModel; import org.onap.policy.models.base.PfUtils; -import org.onap.policy.models.base.PfValidationResult; @Data @EqualsAndHashCode(callSuper = true) @@ -108,11 +109,12 @@ public class DummyPfModel extends PfModel { } @Override - public PfValidationResult validate(final PfValidationResult resultIn) { - PfValidationResult result = super.validate(resultIn); + public BeanValidationResult validate(@NonNull String fieldName) { + BeanValidationResult result = super.validate(fieldName); + int count = 0; for (PfKey pfKey : keyList) { - result = pfKey.validate(result); + result.addResult(pfKey.validate("keyList." + (count++))); } return result; |