From 6345dce40405740dc09176c45dae03baeb939b8e Mon Sep 17 00:00:00 2001 From: Jim Hahn Date: Thu, 17 Dec 2020 12:07:14 -0500 Subject: Use ValidationResult for models v2.0 Policy models uses PfValidationXxx classes which are totally unrelated to ValidationResult in policy common. This precludes the use of various utility methods and annotations for doing validation. Modified policy models to use ValidationResult instead. This approach uses function calls, though a future approach could make use of annotations instead. Issue-ID: POLICY-2648 Change-Id: I9760f1dc46902ab6bef7f440f3caf5e951660a5d Signed-off-by: Jim Hahn --- .../policy/models/base/PfConceptContainerTest.java | 25 +- .../org/onap/policy/models/base/PfKeyImplTest.java | 37 +- .../org/onap/policy/models/base/PfKeyUseTest.java | 10 +- .../org/onap/policy/models/base/PfModelTest.java | 34 +- .../policy/models/base/PfReferenceKeyTest.java | 42 +- .../org/onap/policy/models/base/ValidatedTest.java | 645 +++++++++++---------- .../onap/policy/models/base/ValidationTest.java | 133 ----- .../models/base/testconcepts/DummyPfConcept.java | 24 +- .../models/base/testconcepts/DummyPfKey.java | 6 +- .../models/base/testconcepts/DummyPfModel.java | 12 +- 10 files changed, 403 insertions(+), 565 deletions(-) delete mode 100644 models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java (limited to 'models-base/src/test') 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Map.Entry makeEntry(String key, V value) { + Map 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