diff options
Diffstat (limited to 'models-base')
20 files changed, 740 insertions, 1097 deletions
diff --git a/models-base/pom.xml b/models-base/pom.xml index 75134b79a..cf9c27eef 100644 --- a/models-base/pom.xml +++ b/models-base/pom.xml @@ -33,6 +33,11 @@ <dependencies> <dependency> + <groupId>org.onap.policy.common</groupId> + <artifactId>common-parameters</artifactId> + <version>${policy.common.version}</version> + </dependency> + <dependency> <groupId>org.onap.policy.models</groupId> <artifactId>policy-models-errors</artifactId> <version>${project.version}</version> diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfConcept.java b/models-base/src/main/java/org/onap/policy/models/base/PfConcept.java index 5273bd39e..394eb89f2 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfConcept.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfConcept.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. @@ -30,7 +30,7 @@ import lombok.NonNull; * and interfaces on all concepts that are sub-classes of this class. */ -public abstract class PfConcept implements Serializable, Comparable<PfConcept> { +public abstract class PfConcept extends Validated implements Serializable, Comparable<PfConcept> { private static final long serialVersionUID = -7434939557282697490L; /** @@ -65,15 +65,6 @@ public abstract class PfConcept implements Serializable, Comparable<PfConcept> { public abstract List<PfKey> getKeys(); /** - * Validate that this concept is structurally correct. - * - * @param result the parameter in which the result of the validation will be returned - * @return the validation result that was passed in in the @{link result} field with the result of this validation - * added - */ - public abstract PfValidationResult validate(@NonNull final PfValidationResult result); - - /** * Clean this concept, tidy up any superfluous information such as leading and trailing white space. */ public abstract void clean(); diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java b/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java index 863a3ef02..484632f7c 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java @@ -45,7 +45,8 @@ import lombok.Data; import lombok.EqualsAndHashCode; import lombok.NonNull; import org.apache.commons.lang3.StringUtils; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ValidationResult; // @formatter:off /** @@ -241,19 +242,11 @@ public class PfConceptContainer<C extends PfConcept, A extends PfNameVersion> ex } @Override - public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { - PfValidationResult result = resultIn; + public BeanValidationResult validate(@NonNull String fieldName) { + BeanValidationResult result = new BeanValidationResult(fieldName, this); - if (key.equals(PfConceptKey.getNullKey())) { - result.addValidationMessage( - new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key")); - } - - result = key.validate(result); - - if (!conceptMap.isEmpty()) { - result = validateConceptMap(result); - } + result.addResult(validateKeyNotNull("key", key)); + result.addResult(validateConceptMap()); return result; } @@ -261,29 +254,31 @@ public class PfConceptContainer<C extends PfConcept, A extends PfNameVersion> ex /** * Validate the concept map of the container. * - * @param resultIn the incoming validation results so far - * @return the validation results with the results of this validation added + * @return the validation result */ - private PfValidationResult validateConceptMap(final PfValidationResult resultIn) { - PfValidationResult result = resultIn; + private ValidationResult validateConceptMap() { + BeanValidationResult result = new BeanValidationResult("conceptMap", conceptMap); for (final Entry<PfConceptKey, C> conceptEntry : conceptMap.entrySet()) { + BeanValidationResult result2 = null; + if (conceptEntry.getKey().equals(PfConceptKey.getNullKey())) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key on concept entry " + conceptEntry.getKey() + " may not be the null key")); + addResult(result, "key on concept entry", conceptEntry.getKey(), IS_A_NULL_KEY); } else if (conceptEntry.getValue() == null) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "value on concept entry " + conceptEntry.getKey() + " may not be null")); + result2 = new BeanValidationResult(conceptEntry.getKey().getId(), conceptEntry.getKey()); + addResult(result2, "value", conceptEntry.getValue(), IS_NULL); } else if (!conceptEntry.getKey().equals(conceptEntry.getValue().getKey())) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key on concept entry key " + conceptEntry.getKey() + " does not equal concept value key " - + conceptEntry.getValue().getKey())); - result = conceptEntry.getValue().validate(result); + result2 = new BeanValidationResult(conceptEntry.getKey().getId(), conceptEntry.getKey()); + addResult(result2, "value", conceptEntry.getValue(), "does not equal concept key"); + result2.addResult(conceptEntry.getValue().validate("value")); } else { - result = conceptEntry.getValue().validate(result); + result2 = new BeanValidationResult(conceptEntry.getKey().getId(), conceptEntry.getKey()); + result2.addResult(conceptEntry.getValue().validate("value")); } + + result.addResult(result2); } - return result; + return (result.isClean() ? null : result); } @Override diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfKeyImpl.java b/models-base/src/main/java/org/onap/policy/models/base/PfKeyImpl.java index 81066c37c..3cbef75f9 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfKeyImpl.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfKeyImpl.java @@ -1,7 +1,7 @@ /* * ============LICENSE_START======================================================= * Copyright (C) 2019-2020 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. @@ -26,8 +26,9 @@ import java.util.List; import lombok.Getter; import lombok.NonNull; import lombok.ToString; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ValidationResult; import org.onap.policy.common.utils.validation.Assertions; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; /** * A key, upon which other key subclasses can be built, providing implementations of the methods. @@ -241,20 +242,11 @@ public abstract class PfKeyImpl extends PfKey { } @Override - public PfValidationResult validate(final PfValidationResult result) { - final String nameValidationErrorMessage = - Assertions.getStringParameterValidationMessage(NAME_TOKEN, getName(), getNameRegEx()); - if (nameValidationErrorMessage != null) { - result.addValidationMessage(new PfValidationMessage(this, this.getClass(), ValidationResult.INVALID, - "name invalid-" + nameValidationErrorMessage)); - } + public ValidationResult validate(@NonNull String fieldName) { + BeanValidationResult result = new BeanValidationResult(fieldName, this); - final String versionValidationErrorMessage = - Assertions.getStringParameterValidationMessage(VERSION_TOKEN, getVersion(), getVersionRegEx()); - if (versionValidationErrorMessage != null) { - result.addValidationMessage(new PfValidationMessage(this, this.getClass(), ValidationResult.INVALID, - "version invalid-" + versionValidationErrorMessage)); - } + result.addResult(validateRegex(NAME_TOKEN, getName(), getNameRegEx())); + result.addResult(validateRegex(VERSION_TOKEN, getVersion(), getVersionRegEx())); return result; } diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java b/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java index 03873236c..616284daf 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.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,8 +25,9 @@ import java.util.List; import lombok.EqualsAndHashCode; import lombok.NonNull; import lombok.ToString; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ValidationResult; import org.onap.policy.common.utils.validation.Assertions; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; /** * This class records a usage of a key in the system. When the list of keys being used by a concept @@ -134,12 +135,10 @@ public class PfKeyUse extends PfKey { } @Override - public PfValidationResult validate(@NonNull final PfValidationResult result) { - if (usedKey.isNullKey()) { - result.addValidationMessage(new PfValidationMessage(usedKey, this.getClass(), ValidationResult.INVALID, - "usedKey is a null key")); - } - return usedKey.validate(result); + public ValidationResult validate(@NonNull String fieldName) { + BeanValidationResult result = new BeanValidationResult(fieldName, this); + result.addResult(validateKeyNotNull("usedKey", usedKey)); + return result; } @Override diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfModel.java b/models-base/src/main/java/org/onap/policy/models/base/PfModel.java index 340f4e3b2..c87874774 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfModel.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfModel.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. @@ -32,8 +32,10 @@ import javax.persistence.Table; import lombok.Data; import lombok.EqualsAndHashCode; import lombok.NonNull; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ObjectValidationResult; +import org.onap.policy.common.parameters.ValidationStatus; import org.onap.policy.common.utils.validation.Assertions; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; /** * This class is the base class for all models in the Policy Framework. All model classes inherit @@ -56,7 +58,7 @@ import org.onap.policy.models.base.PfValidationResult.ValidationResult; @Data @EqualsAndHashCode(callSuper = false) public abstract class PfModel extends PfConcept { - private static final String IS_A_NULL_KEY = " is a null key"; + private static final String KEYS_TOKEN = "keys"; private static final long serialVersionUID = -771659065637205430L; @@ -110,15 +112,10 @@ public abstract class PfModel extends PfConcept { } @Override - public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { - PfValidationResult result = resultIn; + public BeanValidationResult 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); + result.addResult(validateKeyNotNull("key", key)); // Key consistency check final Set<PfConceptKey> artifactKeySet = new TreeSet<>(); @@ -128,9 +125,9 @@ public abstract class PfModel extends PfConcept { for (final PfKey pfKey : this.getKeys()) { // Check for the two type of keys we have if (pfKey instanceof PfConceptKey) { - result = validateArtifactKeyInModel((PfConceptKey) pfKey, artifactKeySet, result); + validateArtifactKeyInModel((PfConceptKey) pfKey, artifactKeySet, result); } else if (pfKey instanceof PfReferenceKey) { - result = validateReferenceKeyInModel((PfReferenceKey) pfKey, referenceKeySet, result); + validateReferenceKeyInModel((PfReferenceKey) pfKey, referenceKeySet, result); } else { // It must be a PfKeyUse, nothing else is legal usedKeySet.add((PfKeyUse) pfKey); @@ -140,12 +137,11 @@ public abstract class PfModel extends PfConcept { // Check all reference keys have correct parent keys for (final PfReferenceKey referenceKey : referenceKeySet) { if (!artifactKeySet.contains(referenceKey.getParentConceptKey())) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "parent artifact key not found for reference key " + referenceKey)); + addResult(result, "reference key", referenceKey, "parent artifact key not found"); } } - result = validateKeyUses(usedKeySet, artifactKeySet, referenceKeySet, result); + validateKeyUses(usedKeySet, artifactKeySet, referenceKeySet, result); return result; } @@ -156,78 +152,69 @@ public abstract class PfModel extends PfConcept { * @param artifactKey The artifact key to check * @param artifactKeySet The set of artifact keys encountered so far, this key is appended to * the set - * @param result The validation result to append to - * @return the result of the validation + * @param result where to add the results */ - private PfValidationResult validateArtifactKeyInModel(final PfConceptKey artifactKey, - final Set<PfConceptKey> artifactKeySet, final PfValidationResult result) { - // Null key check - if (artifactKey.isNullKey()) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key " + artifactKey + IS_A_NULL_KEY)); - } + private void validateArtifactKeyInModel(final PfConceptKey artifactKey, + final Set<PfConceptKey> artifactKeySet, final BeanValidationResult result) { + + result.addResult(validateKeyNotNull(KEYS_TOKEN, artifactKey)); + + BeanValidationResult result2 = new BeanValidationResult(KEYS_TOKEN, artifactKey); // Null key name start check if (artifactKey.getName().toUpperCase().startsWith(PfKey.NULL_KEY_NAME)) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key " + artifactKey + " name starts with keyword " + PfKey.NULL_KEY_NAME)); + addResult(result2, "name of " + artifactKey.getId(), artifactKey.getName(), + "starts with keyword " + PfKey.NULL_KEY_NAME); } // Unique key check if (artifactKeySet.contains(artifactKey)) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "duplicate key " + artifactKey + " found")); + addResult(result, KEYS_TOKEN, artifactKey, "duplicate key"); } else { artifactKeySet.add(artifactKey); } - - return result; } /** * Check for consistent usage of a reference key in the model. * - * @param artifactKey The reference key to check + * @param referenceKey The reference key to check * @param referenceKeySet The set of reference keys encountered so far, this key is appended to * the set - * @param result The validation result to append to - * @return the result of the validation + * @param result where to add the results */ - private PfValidationResult validateReferenceKeyInModel(final PfReferenceKey referenceKey, - final Set<PfReferenceKey> referenceKeySet, final PfValidationResult result) { + private void validateReferenceKeyInModel(final PfReferenceKey referenceKey, + final Set<PfReferenceKey> referenceKeySet, final BeanValidationResult result) { // Null key check if (referenceKey.isNullKey()) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key " + referenceKey + IS_A_NULL_KEY)); + addResult(result, KEYS_TOKEN, referenceKey, IS_A_NULL_KEY); } + BeanValidationResult result2 = new BeanValidationResult(KEYS_TOKEN, referenceKey); + // Null parent key check if (referenceKey.getParentConceptKey().isNullKey()) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "parent artifact key of key " + referenceKey + IS_A_NULL_KEY)); + addResult(result2, "parent key of " + referenceKey.getId(), referenceKey.getParentConceptKey().getId(), + IS_A_NULL_KEY); } // Null local name check if (referenceKey.getLocalName().equals(PfKey.NULL_KEY_NAME)) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key " + referenceKey + " has a null local name")); + addResult(result2, "local name of " + referenceKey.getId(), referenceKey.getLocalName(), IS_NULL); } // Null key name start check if (referenceKey.getParentConceptKey().getName().toUpperCase().startsWith(PfKey.NULL_KEY_NAME)) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key " + referenceKey + " parent name starts with keyword " + PfKey.NULL_KEY_NAME)); + addResult(result2, "parent name of " + referenceKey.getId(), referenceKey.getParentConceptKey().getName(), + "starts with keyword " + PfKey.NULL_KEY_NAME); } // Unique key check if (referenceKeySet.contains(referenceKey)) { - result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "duplicate key " + referenceKey + " found")); + addResult(result, KEYS_TOKEN, referenceKey, "duplicate key"); } else { referenceKeySet.add(referenceKey); } - - return result; } /** @@ -238,29 +225,26 @@ public abstract class PfModel extends PfConcept { * the set * @param referenceKeySet The set of reference keys encountered so far, this key is appended to * the set - * @param result The validation result to append to - * @return the result of the validation + * @param result where to add the results */ - private PfValidationResult validateKeyUses(final Set<PfKeyUse> usedKeySet, final Set<PfConceptKey> artifactKeySet, - final Set<PfReferenceKey> referenceKeySet, final PfValidationResult result) { + private void validateKeyUses(final Set<PfKeyUse> usedKeySet, final Set<PfConceptKey> artifactKeySet, + final Set<PfReferenceKey> referenceKeySet, final BeanValidationResult result) { // Check all key uses for (final PfKeyUse usedKey : usedKeySet) { if (usedKey.getKey() instanceof PfConceptKey) { // PfConceptKey usage, check the key exists if (!artifactKeySet.contains(usedKey.getKey())) { - result.addValidationMessage(new PfValidationMessage(usedKey.getKey(), this.getClass(), - ValidationResult.INVALID, "an artifact key used in the model is not defined")); + result.addResult(new ObjectValidationResult("artifact key", usedKey.getId(), + ValidationStatus.INVALID, NOT_DEFINED)); } } else { // PfReferenceKey usage, check the key exists if (!referenceKeySet.contains(usedKey.getKey())) { - result.addValidationMessage(new PfValidationMessage(usedKey.getKey(), this.getClass(), - ValidationResult.INVALID, "a reference key used in the model is not defined")); + result.addResult(new ObjectValidationResult("reference key", usedKey.getId(), + ValidationStatus.INVALID, NOT_DEFINED)); } } } - - return result; } @Override diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java b/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java index 7984e4297..83403ac43 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.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. @@ -28,8 +28,9 @@ import javax.persistence.Embeddable; import lombok.Data; import lombok.EqualsAndHashCode; import lombok.NonNull; +import org.onap.policy.common.parameters.BeanValidationResult; +import org.onap.policy.common.parameters.ValidationResult; import org.onap.policy.common.utils.validation.Assertions; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; /** * A reference key identifies entities in the system that are contained in other entities. Every contained concept in @@ -339,34 +340,13 @@ public class PfReferenceKey extends PfKey { } @Override - public PfValidationResult validate(final PfValidationResult result) { - final String parentNameValidationErrorMessage = Assertions.getStringParameterValidationMessage(PARENT_KEY_NAME, - parentKeyName, NAME_REGEXP); - if (parentNameValidationErrorMessage != null) { - result.addValidationMessage(new PfValidationMessage(this, this.getClass(), ValidationResult.INVALID, - "parentKeyName invalid-" + parentNameValidationErrorMessage)); - } - - final String parentKeyVersionValidationErrorMessage = Assertions - .getStringParameterValidationMessage(PARENT_KEY_VERSION, parentKeyVersion, VERSION_REGEXP); - if (parentKeyVersionValidationErrorMessage != null) { - result.addValidationMessage(new PfValidationMessage(this, this.getClass(), ValidationResult.INVALID, - "parentKeyVersion invalid-" + parentKeyVersionValidationErrorMessage)); - } + public ValidationResult validate(@NonNull String fieldName) { + BeanValidationResult result = new BeanValidationResult(fieldName, this); - final String parentLocalNameValidationErrorMessage = Assertions - .getStringParameterValidationMessage(PARENT_LOCAL_NAME, parentLocalName, LOCAL_NAME_REGEXP); - if (parentLocalNameValidationErrorMessage != null) { - result.addValidationMessage(new PfValidationMessage(this, this.getClass(), ValidationResult.INVALID, - "parentLocalName invalid-" + parentLocalNameValidationErrorMessage)); - } - - final String localNameValidationErrorMessage = Assertions.getStringParameterValidationMessage(LOCAL_NAME, - localName, LOCAL_NAME_REGEXP); - if (localNameValidationErrorMessage != null) { - result.addValidationMessage(new PfValidationMessage(this, this.getClass(), ValidationResult.INVALID, - "localName invalid-" + localNameValidationErrorMessage)); - } + result.addResult(validateRegex(PARENT_KEY_NAME, parentKeyName, NAME_REGEXP)); + result.addResult(validateRegex(PARENT_KEY_VERSION, parentKeyVersion, VERSION_REGEXP)); + result.addResult(validateRegex(PARENT_LOCAL_NAME, parentLocalName, LOCAL_NAME_REGEXP)); + result.addResult(validateRegex(LOCAL_NAME, localName, LOCAL_NAME_REGEXP)); return result; } diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfValidationMessage.java b/models-base/src/main/java/org/onap/policy/models/base/PfValidationMessage.java deleted file mode 100644 index cd8b08bfa..000000000 --- a/models-base/src/main/java/org/onap/policy/models/base/PfValidationMessage.java +++ /dev/null @@ -1,104 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * Copyright (C) 2019 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 org.onap.policy.common.utils.validation.Assertions; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; - -/** - * A validation message is created for each validation observation observed during validation of a - * concept. The message holds the key and the class of the concept on which the observation was made - * as well as the type of observation and a message describing the observation. - */ -public class PfValidationMessage { - private final PfKey observedKey; - private ValidationResult validationResult = ValidationResult.VALID; - private final String observedClass; - private final String message; - - /** - * Create an validation observation with the given fields. - * - * @param observedKey the key of the class on which the validation observation was made - * @param observedClass the class on which the validation observation was made - * @param validationResult the type of observation made - * @param message a message describing the observation - */ - public PfValidationMessage(final PfKey observedKey, final Class<?> observedClass, - final ValidationResult validationResult, final String message) { - Assertions.argumentNotNull(observedKey, "observedKey may not be null"); - Assertions.argumentNotNull(observedClass, "observedClass may not be null"); - Assertions.argumentNotNull(validationResult, "validationResult may not be null"); - Assertions.argumentNotNull(message, "message may not be null"); - - this.observedKey = observedKey; - this.observedClass = observedClass.getName(); - this.validationResult = validationResult; - this.message = message; - } - - /** - * Gets the key of the observation. - * - * @return the key of the observation - */ - public PfKey getObservedKey() { - return observedKey; - } - - /** - * Gets the observed class. - * - * @return the observed class - */ - public String getObservedClass() { - return observedClass; - } - - /** - * Gets the type of observation made. - * - * @return the type of observation made - */ - public ValidationResult getValidationResult() { - return validationResult; - } - - /** - * Get a description of the observation. - * - * @return the observation description - */ - public String getMessage() { - return message; - } - - /* - * (non-Javadoc) - * - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - return observedKey.toString() + ':' + observedClass + ':' + validationResult.name() + ':' + message; - } -} diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java b/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java deleted file mode 100644 index bbac3b7e5..000000000 --- a/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java +++ /dev/null @@ -1,146 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * Copyright (C) 2019-2020 Nordix Foundation. - * ================================================================================ - * 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 java.util.LinkedList; -import java.util.List; -import lombok.Getter; - -/** - * This class records the result of a validation and holds all validation observation messages. - */ -@Getter -public class PfValidationResult { - /** - * The ValidationResult enumeration describes the severity of a validation result. - */ - public enum ValidationResult { - /** No problems or observations were detected during validation. */ - VALID, - /** - * Observations were made on a concept (such as blank descriptions) of a nature that will not affect the use of - * the concept. - */ - OBSERVATION, - /** - * Warnings were made on a concept (such as defined but unused concepts) of a nature that may affect the use of - * the concept. - */ - WARNING, - /** - * Errors were detected on a concept (such as referenced but undefined concepts) of a nature that will affect - * the use of the concept. - */ - INVALID - } - - // The actual verification result - private ValidationResult validationResult = ValidationResult.VALID; - - // Messages collected during the verification process - private final List<PfValidationMessage> messageList = new LinkedList<>(); - - /** - * Check if a validation reported a valid concept, returns true if the model is usable (that is, even if the model - * has warnings or observations). - * - * @return true, if the concept is reported as valid and can be used - */ - public boolean isValid() { - return validationResult != ValidationResult.INVALID; - } - - /** - * Check if a validation reported a concept with no errors or warnings, returns true if the model is OK to use. - * - * @return true, if the concept has no warnings or errors - */ - public boolean isOk() { - return validationResult == ValidationResult.VALID || validationResult == ValidationResult.OBSERVATION; - } - - - /** - * Append a validation result to another validation result. - * - * @param result2Append the result to append to the current validation result - */ - public void append(final PfValidationResult result2Append) { - for (PfValidationMessage message : result2Append.getMessageList()) { - addValidationMessage(message); - } - } - - /** - * Adds a validation message to the validation result, used by validate() implementations on {@link PfConcept} - * subclasses to report validaiton observations. - * - * @param validationMessage the validation message - */ - public void addValidationMessage(final PfValidationMessage validationMessage) { - messageList.add(validationMessage); - - // Check if the incoming message has a more sever status than the - // current one on the overall validation result, - // if so, the overall result goes to that level - if (validationMessage.getValidationResult().ordinal() > validationResult.ordinal()) { - validationResult = validationMessage.getValidationResult(); - } - } - - /* - * (non-Javadoc) - * - * @see java.lang.Object#toString() - */ - @Override - public String toString() { - final StringBuilder builder = new StringBuilder(); - - switch (validationResult) { - case VALID: - - builder.append("***validation of model successful***"); - return builder.toString(); - case OBSERVATION: - - builder.append("\n***observations noted during validation of model***\n"); - break; - case WARNING: - - builder.append("\n***warnings issued during validation of model***\n"); - break; - case INVALID: - builder.append("\n***validation of model failed***\n"); - break; - default: - break; - } - - for (final PfValidationMessage message : messageList) { - builder.append(message); - builder.append("\n"); - } - - builder.append("********************************"); - return builder.toString(); - } -} diff --git a/models-base/src/main/java/org/onap/policy/models/base/Validated.java b/models-base/src/main/java/org/onap/policy/models/base/Validated.java index d79d58f13..b962d46ab 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/Validated.java +++ b/models-base/src/main/java/org/onap/policy/models/base/Validated.java @@ -20,234 +20,343 @@ package org.onap.policy.models.base; +import com.google.re2j.Pattern; import java.util.Collection; import java.util.Map; import java.util.Map.Entry; +import java.util.function.BiFunction; +import java.util.function.Function; import lombok.NonNull; -import org.onap.policy.common.utils.validation.Assertions; -import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.apache.commons.lang3.StringUtils; +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; /** * Classes that can be validated. This can be used as a super class or as a stand-alone * utility class. */ -public class Validated { +public abstract class Validated { + public static final String IS_BLANK = "is blank"; + public static final String IS_A_NULL_KEY = "is a null key"; + public static final String IS_NULL = "is null"; + public static final String NOT_DEFINED = "not defined"; + public static final String NOT_FOUND = "not found"; + + public static final String KEY_TOKEN = "key"; + public static final String VALUE_TOKEN = "value"; + + /** + * Validates the fields of the object. + * + * @param fieldName name of the field containing this + * @return the result, or {@code null} + */ + public abstract ValidationResult validate(String fieldName); /** - * Validates the fields of the object. The default method simply returns the result. + * Adds a result indicating that a value is invalid. * - * @param result where to place the result - * @return the result + * @param result where to put the result + * @param fieldName name of the field containing the value + * @param value the field's value + * @param errorMessage the error message */ - public PfValidationResult validate(@NonNull PfValidationResult result) { - return result; + public static void addResult(@NonNull BeanValidationResult result, @NonNull String fieldName, Object value, + @NonNull String errorMessage) { + result.addResult( + new ObjectValidationResult(fieldName, getKeyId(value), ValidationStatus.INVALID, errorMessage)); } /** - * Validates that a field value is not null. + * Makes a result that indicates a value is invalid, because it is null. * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param value value to be validated - * @param result where to place the result - * @return the result + * @param fieldName name of the field containing the value + * @param value the field's value + * @return a result indicating the value is invalid */ - public PfValidationResult validateNotNull(@NonNull Object container, @NonNull String fieldName, Object value, - @NonNull PfValidationResult result) { + public static ValidationResult makeNullResult(@NonNull String fieldName, Object value) { + return new ObjectValidationResult(fieldName, getKeyId(value), ValidationStatus.INVALID, IS_NULL); + } + /** + * Validates a value, if is not {@code null}, by invoking it's validate() method. + * + * @param result where to put the result + * @param fieldName name of the field containing the value + * @param value the field's value + */ + public static void validateOptional(@NonNull BeanValidationResult result, @NonNull String fieldName, + Validated value) { + if (value != null) { + result.addResult(value.validate(fieldName)); + } + } + + /** + * Validates that a value is not {@code null}. If the value is a subclass of this + * class, then it's {@link #validate(String)} method is invoked, too. + * + * @param fieldName name of the field containing the value + * @param value the field's value + * @return a result, or {@code null} + */ + public static ValidationResult validateNotNull(@NonNull String fieldName, Object value) { if (value == null) { - addError(container, fieldName, result, "null"); + return new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, IS_NULL); + } + + if (value instanceof Validated) { + return ((Validated) value).validate(fieldName); } - return result; + return null; } /** - * Validates that the name and version of a concept key do not have the null default - * values. + * Validates that a value is not "blank" (i.e., empty). value. * - * @param value value to be validated - * @param result where to place the result - * @return the result + * @param fieldName name of the field containing the value + * @param value the field's value + * @param checkNull {@code true} if to validate that the value is not {@code null} + * @return a result, or {@code null} */ - public PfValidationResult validateNotNull(@NonNull PfConceptKey value, @NonNull PfValidationResult result) { - - if (PfKey.NULL_KEY_NAME.equals(value.getName())) { - addError(value, "name", result, "null"); + public static ValidationResult validateNotBlank(@NonNull String fieldName, String value, boolean checkNull) { + if (value == null && !checkNull) { + return null; } - if (PfKey.NULL_KEY_VERSION.equals(value.getVersion())) { - addError(value, "version", result, "null"); + if (StringUtils.isBlank(value)) { + return new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, IS_BLANK); } - return result; + return null; } /** - * Validates the contents of a field, verifying that it matches a pattern, if it is - * non-null. + * Validates that a value matches regular expression. * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param value value to be validated - * @param pattern pattern used to validate the value - * @param result where to place the result - * @return the result + * @param fieldName name of the field containing the value + * @param value the field's value + * @param pattern regular expression to be matched + * @return a result, or {@code null} */ - public PfValidationResult validateText(@NonNull Object container, @NonNull String fieldName, String value, - @NonNull String pattern, @NonNull PfValidationResult result) { + public static ValidationResult validateRegex(@NonNull String fieldName, String value, @NonNull String pattern) { + if (value == null) { + return makeNullResult(fieldName, value); + } - if (value != null) { - addError(container, fieldName, result, - Assertions.getStringParameterValidationMessage(fieldName, value, pattern)); + if (!Pattern.matches(pattern, value)) { + return new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, + "does not match regular expression " + pattern); } - return result; + return null; } /** - * Validates the contents of a property field, verifying that the keys ands values are - * non-null. + * Validates a key, ensuring that it isn't null and that it's structurally sound. * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param properties properties to be validated - * @param resultIn where to place the result - * @return the result + * @param fieldName name of the field containing the key + * @param key the field's value + * @return a result, or {@code null} */ - public <T> PfValidationResult validatePropertiesNotNull(@NonNull Object container, @NonNull String fieldName, - Map<String, T> properties, @NonNull PfValidationResult resultIn) { + public static ValidationResult validateKeyNotNull(@NonNull String fieldName, PfKey key) { + if (key == null) { + return new ObjectValidationResult(fieldName, key, ValidationStatus.INVALID, IS_A_NULL_KEY); + } + + if (key.isNullKey()) { + return new ObjectValidationResult(fieldName, key.getId(), ValidationStatus.INVALID, IS_A_NULL_KEY); + } - PfValidationResult result = resultIn; + return key.validate(fieldName); + } - if (properties == null) { + /** + * Validates a key's version, ensuring that it isn't null. + * + * @param fieldName name of the field containing the key + * @param key the field's value + * @return a result, or {@code null} + */ + public static BeanValidationResult validateKeyVersionNotNull(@NonNull String fieldName, PfConceptKey key) { + if (key != null && key.isNullVersion()) { + BeanValidationResult result = new BeanValidationResult(fieldName, key); + result.addResult(makeNullResult(PfKeyImpl.VERSION_TOKEN, key.getVersion())); return result; } - for (Entry<String, T> ent : properties.entrySet()) { - String key = ent.getKey(); - String keyName = fieldName + "." + key; - result = validateNotNull(container, keyName, key, result); + return null; + } + + /** + * Generates a function to validate that a value is not below a minimum. + * + * @param min minimum value allowed + * @param allowedValue {@code null} or an allowed value outside the range + * @param checkRef {@code true} to generate an error if the value is {@code null} + * @return a function to validate that a value is not below a minimum + */ + public static BiFunction<String, Integer, ValidationResult> validateMin(int min, Integer allowedValue, + boolean checkRef) { + return (name, value) -> validateMin(name, value, min, allowedValue, checkRef); + } + + /** + * Validates that a value is not below a minimum. + * + * @param fieldName name of the field containing the key + * @param value the field's value + * @param min minimum value allowed + * @param allowedValue {@code null} or an allowed value outside the range + * @param checkRef {@code true} to generate an error if the value is {@code null} + * @return a result, or {@code null} + */ + public static ValidationResult validateMin(@NonNull String fieldName, Integer value, int min, Integer allowedValue, + boolean checkRef) { + if (value == null) { + if (checkRef) { + return makeNullResult(fieldName, value); + } + + return null; + } - result = validateNotNull(container, keyName, ent.getValue(), result); + if (value < min && !value.equals(allowedValue)) { + return new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, + "is below the minimum value: " + min); } - return result; + return null; } /** - * Validates the items in a collection field are non-null. + * Validates the items in a list. * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param collection collection whose items are to be validated - * @param resultIn where to place the result - * @return the result + * @param result where to add the results + * @param fieldName name of the field containing the list + * @param list the field's list (may be {@code null}) + * @param checker function to validate in individual item in the list */ - public <T> PfValidationResult validateCollectionNotNull(@NonNull Object container, @NonNull String fieldName, - Collection<T> collection, @NonNull PfValidationResult resultIn) { + public static <T> void validateList(@NonNull BeanValidationResult result, @NonNull String fieldName, + Collection<T> list, @NonNull BiFunction<String, T, ValidationResult> checker) { + if (list == null) { + return; + } - PfValidationResult result = resultIn; + BeanValidationResult result2 = new BeanValidationResult(fieldName, list); - if (collection == null) { - return result; + int count = 0; + for (T value : list) { + result2.addResult(checker.apply(String.valueOf(count++), value)); } - String prefix = fieldName + "."; - int count = 0; + if (!result2.isClean()) { + result.addResult(result2); + } + } + + /** + * Validates the items in a map. + * + * @param result where to add the results + * @param fieldName name of the field containing the list + * @param map the field's map (may be {@code null}) + * @param checker function to validate in individual item in the list + */ + public static <T> void validateMap(@NonNull BeanValidationResult result, @NonNull String fieldName, + Map<String, T> map, @NonNull Function<Map.Entry<String, T>, ValidationResult> checker) { + if (map == null) { + return; + } - for (T item : collection) { - result = validateNotNull(container, prefix + count, item, result); - ++count; + BeanValidationResult result2 = new BeanValidationResult(fieldName, map); + + for (Entry<String, T> entry : map.entrySet()) { + result2.addResult(checker.apply(entry)); } - return result; + if (!result2.isClean()) { + result.addResult(result2); + } } /** - * Invokes the "validate()" method on each item in a collection field, if the item is - * non-null. + * Validates a Map entry, ensuring that neither the key nor the value are "blank" + * (i.e., empty or {@code null}). * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param collection collection whose items are to be validated - * @param result where to place the result - * @return the result + * @param entry entry to be validated + * @return a result, or {@code null} */ - public <T extends Validated> PfValidationResult validateCollection(@NonNull Object container, - @NonNull String fieldName, Collection<T> collection, @NonNull PfValidationResult result) { + public static BeanValidationResult validateEntryNotBlankNotBlank(Map.Entry<String, String> entry) { + BeanValidationResult result = new BeanValidationResult("" + entry.getKey(), entry.getKey()); - if (collection == null) { - return result; + if (StringUtils.isBlank(entry.getKey())) { + Validated.addResult(result, KEY_TOKEN, entry.getKey(), IS_BLANK); } - for (T item : collection) { - if (item != null) { - result = item.validate(result); - } + if (StringUtils.isBlank(entry.getValue())) { + Validated.addResult(result, VALUE_TOKEN, entry.getValue(), IS_BLANK); } - return result; + return (result.isClean() ? null : result); } /** - * Invokes the "validate()" method on each item in a concept collection field, if the - * item is non-null. + * Validates a Map entry, ensuring that the key is not "blank" (i.e., empty or + * {@code null}) and the value is not {@code null}. * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param collection collection whose items are to be validated - * @param result where to place the result - * @return the result + * @param entry entry to be validated + * @return a result, or {@code null} */ - public <T extends PfConcept> PfValidationResult validateConceptCollection(@NonNull Object container, - @NonNull String fieldName, Collection<T> collection, @NonNull PfValidationResult result) { + public static BeanValidationResult validateEntryNotBlankNotNull(Map.Entry<String, String> entry) { + BeanValidationResult result = new BeanValidationResult("" + entry.getKey(), entry.getKey()); - if (collection == null) { - return result; + if (StringUtils.isBlank(entry.getKey())) { + Validated.addResult(result, KEY_TOKEN, entry.getKey(), IS_BLANK); } - for (T item : collection) { - if (item != null) { - result = item.validate(result); - } + if (entry.getValue() == null) { + result.addResult(makeNullResult(VALUE_TOKEN, entry.getValue())); } - return result; + return (result.isClean() ? null : result); } /** - * Adds an error message to the validation result. + * Validates a Map entry, ensuring that neither the key nor the value are + * {@code null}. If the value is a subclass of this class, then it's + * {@link #validate(String)} method is invoked. * - * @param container the object that contains the field - * @param fieldName name of the field to be validated - * @param result where to place the result - * @param errmsg the error message to be added, or {@code null} if nothing to add + * @param entry entry to be validated + * @return a result, or {@code null} */ - public void addError(@NonNull Object container, @NonNull String fieldName, @NonNull PfValidationResult result, - String errmsg) { - if (errmsg != null) { - result.addValidationMessage(new PfValidationMessage(makeKey(container), container.getClass(), - ValidationResult.INVALID, fieldName + " invalid-" + errmsg)); + public static <V> BeanValidationResult validateEntryValueNotNull(Map.Entry<String, V> entry) { + BeanValidationResult result = new BeanValidationResult("" + entry.getKey(), entry.getKey()); + + if (entry.getKey() == null) { + result.addResult(makeNullResult(KEY_TOKEN, entry.getKey())); + } + + V value = entry.getValue(); + if (value == null) { + result.addResult(makeNullResult(VALUE_TOKEN, value)); + } else if (value instanceof Validated) { + result.addResult(((Validated) value).validate(VALUE_TOKEN)); } + + return (result.isClean() ? null : result); } /** - * Makes a PfKey suitable for insertion into a validation message. Note: the - * "toString()" method of the key simply invokes container.toString(); + * Gets a key's ID, if the value is a {@link PfKey}. * - * @param container the container object for which the key should be made - * @return a key for the container + * @param value value from which to get the ID + * @return the value's ID, if it's a key, the original value otherwise */ - public PfKey makeKey(@NonNull Object container) { - - return new PfConceptKey() { - private static final long serialVersionUID = 1L; - - @Override - public String toString() { - return container.toString(); - } - }; + private static Object getKeyId(Object value) { + return (value instanceof PfKey ? ((PfKey) value).getId() : value); } } 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; |