diff options
Diffstat (limited to 'models-base')
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()); - } -} |