Merge "Add PolicyIdentOptVersion"

5 files changed, 694 insertions, 148 deletions

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
new file mode 100644
index 000000000..7a0a8377b
--- /dev/null
+++ b/models-base/src/main/java/org/onap/policy/models/base/Validated.java
@@ -0,0 +1,253 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  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 java.util.Collection;
+import java.util.Map;
+import java.util.Map.Entry;
+import lombok.NonNull;
+import org.onap.policy.common.utils.validation.Assertions;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+
+/**
+ * Classes that can be validated. This can be used as a super class or as a stand-alone
+ * utility class.
+ */
+public class Validated {
+
+    /**
+     * Validates the fields of the object. The default method simply returns the result.
+     *
+     * @param result where to place the result
+     * @return the result
+     */
+    public PfValidationResult validate(@NonNull PfValidationResult result) {
+        return result;
+    }
+
+    /**
+     * Validates that a field value is not 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
+     */
+    public PfValidationResult validateNotNull(@NonNull Object container, @NonNull String fieldName, Object value,
+                    @NonNull PfValidationResult result) {
+
+        if (value == null) {
+            addError(container, fieldName, result, "null");
+        }
+
+        return result;
+    }
+
+    /**
+     * Validates that the name and version of a concept key do not have the null default
+     * values.
+     *
+     * @param value value to be validated
+     * @param result where to place the result
+     * @return the result
+     */
+    public PfValidationResult validateNotNull(@NonNull PfConceptKey value, @NonNull PfValidationResult result) {
+
+        if (PfConceptKey.NULL_KEY_NAME.equals(value.getName())) {
+            addError(value, "name", result, "null");
+        }
+
+        if (PfConceptKey.NULL_KEY_VERSION.equals(value.getVersion())) {
+            addError(value, "version", result, "null");
+        }
+
+        return result;
+    }
+
+    /**
+     * Validates the contents of a field, verifying that it matches a pattern, if it is
+     * non-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 pattern pattern used to validate the value
+     * @param result where to place the result
+     * @return the result
+     */
+    public PfValidationResult validateText(@NonNull Object container, @NonNull String fieldName, String value,
+                    @NonNull String pattern, @NonNull PfValidationResult result) {
+
+        if (value != null) {
+            addError(container, fieldName, result,
+                            Assertions.getStringParameterValidationMessage(fieldName, value, pattern));
+        }
+
+        return result;
+    }
+
+    /**
+     * Validates the contents of a property field, verifying that the keys ands values are
+     * non-null.
+     *
+     * @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
+     */
+    public <T> PfValidationResult validatePropertiesNotNull(@NonNull Object container, @NonNull String fieldName,
+                    Map<String, T> properties, @NonNull PfValidationResult resultIn) {
+
+        PfValidationResult result = resultIn;
+
+        if (properties == null) {
+            return result;
+        }
+
+        for (Entry<String, T> ent : properties.entrySet()) {
+            String key = ent.getKey();
+            String keyName = fieldName + "." + key;
+            result = validateNotNull(container, keyName, key, result);
+
+            result = validateNotNull(container, keyName, ent.getValue(), result);
+        }
+
+        return result;
+    }
+
+    /**
+     * Validates the items in a collection field are non-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 resultIn where to place the result
+     * @return the result
+     */
+    public <T> PfValidationResult validateCollectionNotNull(@NonNull Object container, @NonNull String fieldName,
+                    Collection<T> collection, @NonNull PfValidationResult resultIn) {
+
+        PfValidationResult result = resultIn;
+
+        if (collection == null) {
+            return result;
+        }
+
+        String prefix = fieldName + ".";
+        int count = 0;
+
+        for (T item : collection) {
+            result = validateNotNull(container, prefix + count, item, result);
+            ++count;
+        }
+
+        return result;
+    }
+
+    /**
+     * Invokes the "validate()" method on each item in a collection field, if the item is
+     * non-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
+     */
+    public <T extends Validated> PfValidationResult validateCollection(@NonNull Object container,
+                    @NonNull String fieldName, Collection<T> collection, @NonNull PfValidationResult result) {
+
+        if (collection == null) {
+            return result;
+        }
+
+        for (T item : collection) {
+            if (item != null) {
+                result = item.validate(result);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Invokes the "validate()" method on each item in a concept collection field, if the
+     * item is non-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
+     */
+    public <T extends PfConcept> PfValidationResult validateConceptCollection(@NonNull Object container,
+                    @NonNull String fieldName, Collection<T> collection, @NonNull PfValidationResult result) {
+
+        if (collection == null) {
+            return result;
+        }
+
+        for (T item : collection) {
+            if (item != null) {
+                result = item.validate(result);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Adds an error message to the validation result.
+     *
+     * @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
+     */
+    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));
+        }
+    }
+
+    /**
+     * Makes a PfKey suitable for insertion into a validation message. Note: the
+     * "toString()" method of the key simply invokes container.toString();
+     *
+     * @param container the container object for which the key should be made
+     * @return a key for the container
+     */
+    public PfKey makeKey(@NonNull Object container) {
+
+        return new PfConceptKey() {
+            private static final long serialVersionUID = 1L;
+
+            @Override
+            public String toString() {
+                return container.toString();
+            }
+        };
+    }
+}
diff --git a/models-base/src/main/java/org/onap/policy/models/base/keys/PolicyTypeIdent.java b/models-base/src/main/java/org/onap/policy/models/base/keys/PolicyTypeIdent.java
deleted file mode 100644
index 09e03816e..000000000
--- a/models-base/src/main/java/org/onap/policy/models/base/keys/PolicyTypeIdent.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * ============LICENSE_START=======================================================
- * ONAP Policy Models
- * ================================================================================
- * 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.
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.policy.models.base.keys;
-
-import lombok.NoArgsConstructor;
-import lombok.NonNull;
-import org.onap.policy.models.base.PfConceptKey;
-
-/**
- * Identifies a policy type. Both the name and version must be non-null.
- */
-@NonNull
-@NoArgsConstructor
-public class PolicyTypeIdent extends PfConceptKey {
-    private static final long serialVersionUID = 1L;
-
-    public PolicyTypeIdent(String name, String version) {
-        super(name, version);
-    }
-
-    public PolicyTypeIdent(PolicyTypeIdent source) {
-        super(source);
-    }
-}
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
new file mode 100644
index 000000000..391e7333b
--- /dev/null
+++ b/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java
@@ -0,0 +1,441 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP Policy Models
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.base;
+
+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.List;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ValidatedTest {
+    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();
+    }
+
+    @Test
+    public void testValidate() {
+        assertThatThrownBy(() -> validated.validate(null)).isInstanceOf(NullPointerException.class);
+
+        PfValidationResult result = new PfValidationResult();
+        assertSame(result, validated.validate(result));
+        assertTrue(result.isValid());
+        assertEquals(0, result.getMessageList().size());
+    }
+
+    @Test
+    public void testValidateNotNull() {
+        PfValidationResult result = new PfValidationResult();
+
+        final PfValidationResult result2 = result;
+        assertThatThrownBy(() -> validated.validateNotNull(null, VALID_FIELD, VALID_VALUE, result2))
+                        .isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateNotNull(this, null, VALID_VALUE, result2))
+                        .isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateNotNull(this, VALID_FIELD, VALID_VALUE, null))
+                        .isInstanceOf(NullPointerException.class);
+
+        // null text
+        result = validated.validateNotNull(this, NULL_FIELD, null, result);
+
+        // invalid text
+        result = validated.validateNotNull(this, INVALID_FIELD, "!!!", result);
+
+        // valid text
+        result = validated.validateNotNull(this, VALID_FIELD, VALID_VALUE, result);
+
+        // different value
+        result = validated.validateNotNull(this, VALID_FIELD, Integer.valueOf(10), result);
+
+        assertFalse(result.isValid());
+        assertEquals(1, result.getMessageList().size());
+
+        // 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"));
+    }
+
+    @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"));
+
+        final PfConceptKey key2 = key;
+        assertThatThrownBy(() -> validated.validateNotNull(key2, null)).isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateNotNull(null, new PfValidationResult()))
+                        .isInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    public void testValidateText() {
+        PfValidationResult result = new PfValidationResult();
+
+        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);
+
+        // null text
+        result = validated.validateText(this, NULL_FIELD, null, WORD_PAT, result);
+
+        // invalid text
+        result = validated.validateText(this, INVALID_FIELD, "!!!", WORD_PAT, result);
+
+        // valid text
+        result = validated.validateText(this, VALID_FIELD, VALID_VALUE, WORD_PAT, result);
+
+        assertFalse(result.isValid());
+        assertEquals(1, result.getMessageList().size());
+
+        // 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"));
+    }
+
+    @Test
+    public void testValidatePropertiesNotNull() {
+        PfValidationResult result = new PfValidationResult();
+        result = validated.validatePropertiesNotNull(this, "properties", null, result);
+        assertTrue(result.isValid());
+        assertEquals(0, result.getMessageList().size());
+
+        Map<String, Integer> map = new LinkedHashMap<>();
+
+        // null key
+        map.put(null, 10);
+
+        // null value
+        map.put("abc", null);
+
+        // valid key & value
+        map.put("def", 11);
+
+
+        result = validated.validatePropertiesNotNull(this, PROPS_FIELD, map, result);
+
+        assertFalse(result.isValid());
+        assertEquals(2, result.getMessageList().size());
+
+        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
+
+        // 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"));
+
+        // 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"));
+
+        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);
+    }
+
+    @Test
+    public void testValidateCollectionNotNull() {
+        PfValidationResult result = new PfValidationResult();
+        result = validated.validateCollectionNotNull(this, "collection", null, result);
+        assertTrue(result.isValid());
+        assertEquals(0, result.getMessageList().size());
+
+        final List<String> lst = Arrays.asList("abc", null, "def", null);
+
+        result = validated.validateCollectionNotNull(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(ValidatedTest.class.getName(), msg.getObservedClass());
+        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
+        assertTrue(msg.getMessage().contains("coll.1 invalid-null"));
+
+        // 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);
+    }
+
+    @Test
+    public void testValidateCollection() {
+        PfValidationResult result = new PfValidationResult();
+        result = validated.validateCollection(this, "collection", 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().replace('$', '.'), 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().replace('$', '.'), 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))
+                        .isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateCollection(this, null, lst, result2))
+                        .isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateCollection(this, COLLECTION_FIELD, lst, null))
+                        .isInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    public void testValidateConceptCollection() {
+        PfValidationResult result = new PfValidationResult();
+        result = validated.validateConceptCollection(this, "collection", 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().replace('$', '.'), 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().replace('$', '.'), 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))
+                        .isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateConceptCollection(this, null, lst, result2))
+                        .isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> validated.validateConceptCollection(this, COLLECTION_FIELD, lst, null))
+                        .isInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    public void testAddError() {
+        final PfValidationResult result = new PfValidationResult();
+        final PfValidationResult result2 = result;
+
+        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");
+
+        assertFalse(result.isValid());
+        assertEquals(2, result.getMessageList().size());
+
+        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
+
+        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"));
+
+        msg = it.next();
+        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
+        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
+        assertTrue(msg.getMessage().contains("validField invalid-error-B"));
+    }
+
+    @Test
+    public void testMakeKey() {
+        assertThatThrownBy(() -> validated.makeKey(null)).isInstanceOf(NullPointerException.class);
+
+        PfKey key = validated.makeKey(this);
+        assertEquals(MY_TO_STRING, key.toString());
+    }
+
+    @Override
+    public String toString() {
+        return MY_TO_STRING;
+    }
+
+    private static class MyValid extends Validated {
+        private boolean valid;
+        private int index;
+
+        public MyValid(int index, boolean valid) {
+            this.index = index;
+            this.valid = valid;
+        }
+
+        @Override
+        public PfValidationResult validate(PfValidationResult result) {
+            if (!valid) {
+                this.addError(this, "index." + index, result, "wrong value");
+            }
+
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return MY_TO_STRING;
+        }
+    }
+
+    private static class MyConcept extends PfConceptKey {
+        private static final long serialVersionUID = 1L;
+
+        private boolean valid;
+        private int index;
+
+        public MyConcept(int index, boolean valid) {
+            this.index = index;
+            this.valid = valid;
+        }
+
+        @Override
+        public PfValidationResult validate(PfValidationResult result) {
+            if (!valid) {
+                new Validated().addError(this, "index." + index, result, "wrong value");
+            }
+
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return MY_TO_STRING;
+        }
+    }
+}
diff --git a/models-base/src/test/java/org/onap/policy/models/base/keys/TestModels.java b/models-base/src/test/java/org/onap/policy/models/base/keys/TestModels.java
deleted file mode 100644
index a1bf3be68..000000000
--- a/models-base/src/test/java/org/onap/policy/models/base/keys/TestModels.java
+++ /dev/null
@@ -1,46 +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.keys;
-
-import com.openpojo.reflection.filters.FilterPackageInfo;
-import com.openpojo.validation.Validator;
-import com.openpojo.validation.ValidatorBuilder;
-import com.openpojo.validation.test.impl.GetterTester;
-import com.openpojo.validation.test.impl.SetterTester;
-
-import org.junit.Test;
-import org.onap.policy.common.utils.validation.ToStringTester;
-
-/**
- * Class to perform unit testing of models.
- *
- * @author Ram Krishna Verma (ram.krishna.verma@est.tech)
- */
-public class TestModels {
-
-    @Test
-    public void testModels() {
-        final Validator validator = ValidatorBuilder.create().with(new ToStringTester()).with(new SetterTester())
-                .with(new GetterTester()).build();
-        validator.validate(TestModels.class.getPackage().getName(), new FilterPackageInfo());
-    }
-}
diff --git a/models-base/src/test/java/org/onap/policy/models/base/keys/TestPolicyTypeIdent.java b/models-base/src/test/java/org/onap/policy/models/base/keys/TestPolicyTypeIdent.java
deleted file mode 100644
index 1638a87da..000000000
--- a/models-base/src/test/java/org/onap/policy/models/base/keys/TestPolicyTypeIdent.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * ============LICENSE_START=======================================================
- * ONAP Policy Models
- * ================================================================================
- * 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.
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.policy.models.base.keys;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.onap.policy.models.base.keys.PolicyTypeIdent;
-import org.onap.policy.models.base.keys.TestModels;
-
-/**
- * Test the other constructors, as {@link TestModels} tests the other methods.
- */
-public class TestPolicyTypeIdent {
-    private static final String NAME = "my-name";
-    private static final String VERSION = "1.2.3";
-
-    @Test
-    public void testAllArgsConstructor() {
-        assertThatThrownBy(() -> new PolicyTypeIdent(null, VERSION)).isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> new PolicyTypeIdent(NAME, null)).isInstanceOf(NullPointerException.class);
-
-        PolicyTypeIdent orig = new PolicyTypeIdent(NAME, VERSION);
-        assertEquals(NAME, orig.getName());
-        assertEquals(VERSION, orig.getVersion());
-    }
-
-    @Test
-    public void testCopyConstructor() {
-        assertThatThrownBy(() -> new PolicyTypeIdent(null)).isInstanceOf(NullPointerException.class);
-
-        PolicyTypeIdent orig = new PolicyTypeIdent();
-
-        // verify with null values
-        assertEquals(orig.toString(), new PolicyTypeIdent(orig).toString());
-
-        // verify with all values
-        orig = new PolicyTypeIdent(NAME, VERSION);
-        assertEquals(orig.toString(), new PolicyTypeIdent(orig).toString());
-    }
-}