Add PolicyIdentOptVersion

Added additional PolicyIdentXxx classes.  Added PdpDeployPolicies, which
makes use of it, thus eliminating the need for PdpPolicies, which will be
deleted once the PAP has been modified to use the new code.
Added Validated class to facilitate field validation.
Added utility methods to Validated class.
Use new validator methods in PolicyIdentXxx classes.
Use addError() method in validator class.
Use parameter types instead of "?".
Use static Validator instead of local.
Get "result" from each call to a validateXxx() method.
Derived PolicyIdentOptVersion from PfConceptKey.
Moved PolicyIdent classes to models-pdp.
Added PolicyIdent classes to models-pap.
Also removed copy constructors from classes in models-pap, as those
are plain POJOs that will not be copied.  Copy constructors will be
added to new classes that will be added to models-pdp in a separate
review.

Forgot to include the new Ident classes in models-pap.

Change-Id: I923132c464c7802ee3e9225685cde44f36c64620
Issue-ID: POLICY-1542
Signed-off-by: Jim Hahn <jrh3@att.com>

3 files changed, 441 insertions, 106 deletions

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());
-    }
-}