From 4c4946e339942863e73e20726dd95aaacfcfb5a6 Mon Sep 17 00:00:00 2001 From: liamfallon Date: Mon, 7 Dec 2020 16:25:14 +0000 Subject: [PATCH] JPA concepts for TOSCA Implement the Database persistence parts for the new TOSCA concepts so that those concepts can be written to and read from the database. First batch of comment fixes Issue-ID: POLICY-2900 Change-Id: I45191c1ff57cf1ea8563399db6cc8e51b2724813 Signed-off-by: liamfallon --- .../policy/models/base/PfConceptContainer.java | 36 ++- .../java/org/onap/policy/models/base/PfUtils.java | 34 +++ .../policy/models/base/PfValidationResult.java | 59 ++-- .../onap/policy/models/base/ValidationTest.java | 59 +++- .../src/test/resources/META-INF/persistence.xml | 27 +- .../concepts/JpaToscaCapabilityAssignment.java | 271 ++++++++++++++++++ .../concepts/JpaToscaCapabilityAssignments.java | 117 ++++++++ .../simple/concepts/JpaToscaCapabilityType.java | 239 ++++++++++++++++ .../simple/concepts/JpaToscaCapabilityTypes.java | 112 ++++++++ .../tosca/simple/concepts/JpaToscaDataType.java | 46 +-- .../tosca/simple/concepts/JpaToscaEntityType.java | 33 +-- .../tosca/simple/concepts/JpaToscaEventFilter.java | 16 +- .../tosca/simple/concepts/JpaToscaModel.java | 20 +- .../simple/concepts/JpaToscaNodeTemplate.java | 310 +++++++++++++++++++++ .../simple/concepts/JpaToscaNodeTemplates.java | 112 ++++++++ .../tosca/simple/concepts/JpaToscaNodeType.java | 277 ++++++++++++++++++ .../tosca/simple/concepts/JpaToscaNodeTypes.java | 112 ++++++++ .../tosca/simple/concepts/JpaToscaParameter.java | 202 ++++++++++++++ .../tosca/simple/concepts/JpaToscaPolicy.java | 99 +++---- .../tosca/simple/concepts/JpaToscaPolicyType.java | 36 +-- .../tosca/simple/concepts/JpaToscaProperty.java | 68 ++--- .../simple/concepts/JpaToscaRelationshipType.java | 236 ++++++++++++++++ .../simple/concepts/JpaToscaRelationshipTypes.java | 113 ++++++++ .../tosca/simple/concepts/JpaToscaRequirement.java | 303 ++++++++++++++++++++ .../simple/concepts/JpaToscaRequirements.java | 116 ++++++++ ...rySchema.java => JpaToscaSchemaDefinition.java} | 24 +- .../simple/concepts/JpaToscaServiceTemplate.java | 129 +++++++++ .../simple/concepts/JpaToscaTimeInterval.java | 13 +- .../simple/concepts/JpaToscaTopologyTemplate.java | 123 +++++++- .../tosca/simple/concepts/JpaToscaTrigger.java | 12 +- .../tosca/utils/ToscaServiceTemplateUtils.java | 4 +- .../concepts/JpaToscaCapabilityAssignmentTest.java | 158 +++++++++++ .../simple/concepts/JpaToscaDataTypeTest.java | 4 +- .../tosca/simple/concepts/JpaToscaPolicyTest.java | 46 ++- .../simple/concepts/JpaToscaPolicyTypeTest.java | 4 +- .../simple/concepts/JpaToscaPropertyTest.java | 6 +- ...Test.java => JpaToscaSchemaDefinitionTest.java} | 24 +- .../concepts/JpaToscaServiceTemplateTest.java | 3 + .../simple/provider/SimpleToscaProviderTest.java | 133 ++++----- .../OptimizationPolicyTypeSerializationTest.java | 3 +- .../src/test/resources/META-INF/persistence.xml | 19 +- 41 files changed, 3376 insertions(+), 382 deletions(-) create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipType.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java create mode 100644 models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java rename models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/{JpaToscaEntrySchema.java => JpaToscaSchemaDefinition.java} (89%) create mode 100644 models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java rename models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/{JpaToscaEntrySchemaTest.java => JpaToscaSchemaDefinitionTest.java} (81%) diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java b/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java index 77ef939bd..863a3ef02 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java @@ -66,7 +66,7 @@ import org.onap.policy.models.base.PfValidationResult.ValidationResult; @EqualsAndHashCode(callSuper = false) public class PfConceptContainer extends PfConcept - implements PfConceptGetter, PfAuthorative>> { + implements PfConceptGetter, PfAuthorative>> { private static final long serialVersionUID = -324211738823208318L; private static final Pattern KEY_ID_PATTERN = Pattern.compile(PfKey.KEY_ID_REGEXP); @@ -193,9 +193,9 @@ public class PfConceptContainer ex } incomingConceptEntry.getValue().setName(findConceptField(conceptKey, conceptKey.getName(), - incomingConceptEntry.getValue(), PfNameVersion::getName)); + incomingConceptEntry.getValue(), PfNameVersion::getName)); incomingConceptEntry.getValue().setVersion(findConceptField(conceptKey, conceptKey.getVersion(), - incomingConceptEntry.getValue(), PfNameVersion::getVersion)); + incomingConceptEntry.getValue(), PfNameVersion::getVersion)); C jpaConcept = getConceptNewInstance(); // This cast allows us to call the fromAuthorative method @@ -212,7 +212,7 @@ public class PfConceptContainer ex if (conceptMap.isEmpty()) { throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, - "An incoming list of concepts must have at least one entry"); + "An incoming list of concepts must have at least one entry"); } } @@ -246,7 +246,7 @@ public class PfConceptContainer ex if (key.equals(PfConceptKey.getNullKey())) { result.addValidationMessage( - new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key")); + new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key")); } result = key.validate(result); @@ -270,14 +270,14 @@ public class PfConceptContainer ex for (final Entry conceptEntry : conceptMap.entrySet()) { if (conceptEntry.getKey().equals(PfConceptKey.getNullKey())) { result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key on concept entry " + conceptEntry.getKey() + " may not be the null key")); + "key on concept entry " + conceptEntry.getKey() + " may not be the null key")); } else if (conceptEntry.getValue() == null) { result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "value on concept entry " + conceptEntry.getKey() + " may not be null")); + "value on concept entry " + conceptEntry.getKey() + " may not be null")); } else if (!conceptEntry.getKey().equals(conceptEntry.getValue().getKey())) { result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, - "key on concept entry key " + conceptEntry.getKey() + " does not equal concept value key " - + conceptEntry.getValue().getKey())); + "key on concept entry key " + conceptEntry.getKey() + " does not equal concept value key " + + conceptEntry.getValue().getKey())); result = conceptEntry.getValue().validate(result); } else { result = conceptEntry.getValue().validate(result); @@ -305,11 +305,7 @@ public class PfConceptContainer ex return retVal; } - if (!conceptMap.equals(other.conceptMap)) { - return (conceptMap.hashCode() - other.conceptMap.hashCode()); - } - - return 0; + return PfUtils.compareMaps(conceptMap, other.conceptMap); } /** @@ -349,7 +345,7 @@ public class PfConceptContainer ex @Override public C get(final String conceptKeyName, final String conceptKeyVersion) { return new PfConceptGetterImpl<>((NavigableMap) conceptMap).get(conceptKeyName, - conceptKeyVersion); + conceptKeyVersion); } @Override @@ -360,7 +356,7 @@ public class PfConceptContainer ex @Override public Set getAll(final String conceptKeyName, final String conceptKeyVersion) { return new PfConceptGetterImpl<>((NavigableMap) conceptMap).getAll(conceptKeyName, - conceptKeyVersion); + conceptKeyVersion); } /** @@ -372,16 +368,16 @@ public class PfConceptContainer ex private C getConceptNewInstance() { try { String conceptClassName = - ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName(); + ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName(); return (C) Class.forName(conceptClassName).getDeclaredConstructor().newInstance(); } catch (Exception ex) { throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, - "failed to instantiate instance of container concept class", ex); + "failed to instantiate instance of container concept class", ex); } } private String findConceptField(final PfConceptKey conceptKey, final String keyFieldValue, - final PfNameVersion concept, final Function fieldGetterFunction) { + final PfNameVersion concept, final Function fieldGetterFunction) { String conceptField = fieldGetterFunction.apply(concept); @@ -389,7 +385,7 @@ public class PfConceptContainer ex return keyFieldValue; } else { throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, "Key " + conceptKey.getId() + " field " - + keyFieldValue + " does not match the value " + conceptField + " in the concept field"); + + keyFieldValue + " does not match the value " + conceptField + " in the concept field"); } } } diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java b/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java index d5b70d78a..57d23450a 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java @@ -22,6 +22,7 @@ package org.onap.policy.models.base; import java.lang.reflect.InvocationTargetException; +import java.util.Collection; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -29,6 +30,8 @@ import java.util.Map.Entry; import java.util.function.Function; import java.util.stream.Collectors; import javax.ws.rs.core.Response; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; /** * Utility class for Policy Framework concept utilities. @@ -67,6 +70,37 @@ public final class PfUtils { return 0; } + /** + * Compare two collections of the same type, nulls are allowed. + * + * @param leftCollection the first collection + * @param rightCollection the second collection + * @return a measure of the comparison + */ + public static int compareCollections(final Collection leftCollection, final Collection rightCollection) { + if (CollectionUtils.isEmpty(leftCollection) && CollectionUtils.isEmpty(rightCollection)) { + return 0; + } + + return compareObjects(leftCollection, rightCollection); + } + + + /** + * Compare two maps of the same type, nulls are allowed. + * + * @param leftMap the first map + * @param rightMap the second map + * @return a measure of the comparison + */ + public static int compareMaps(final Map leftMap, final Map rightMap) { + if (MapUtils.isEmpty(leftMap) && MapUtils.isEmpty(rightMap)) { + return 0; + } + + return compareObjects(leftMap, rightMap); + } + /** * Convenience method to apply a mapping function to all of the elements of a list, generating a new list. * diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java b/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java index 6f4633612..bbac3b7e5 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfValidationResult.java @@ -1,6 +1,6 @@ /*- * ============LICENSE_START======================================================= - * Copyright (C) 2019 Nordix Foundation. + * Copyright (C) 2019-2020 Nordix Foundation. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -33,23 +33,23 @@ public class PfValidationResult { * The ValidationResult enumeration describes the severity of a validation result. */ public enum ValidationResult { - /** No problems or observations were detected during validation. */ - VALID, - /** - * Observations were made on a concept (such as blank descriptions) of a nature that will not - * affect the use of the concept. - */ - OBSERVATION, - /** - * Warnings were made on a concept (such as defined but unused concepts) of a nature that may - * affect the use of the concept. - */ - WARNING, - /** - * Errors were detected on a concept (such as referenced but undefined concepts) of a nature - * that will affect the use of the concept. - */ - INVALID + /** No problems or observations were detected during validation. */ + VALID, + /** + * Observations were made on a concept (such as blank descriptions) of a nature that will not affect the use of + * the concept. + */ + OBSERVATION, + /** + * Warnings were made on a concept (such as defined but unused concepts) of a nature that may affect the use of + * the concept. + */ + WARNING, + /** + * Errors were detected on a concept (such as referenced but undefined concepts) of a nature that will affect + * the use of the concept. + */ + INVALID } // The actual verification result @@ -59,8 +59,8 @@ public class PfValidationResult { private final List messageList = new LinkedList<>(); /** - * Check if a validation reported a valid concept, returns true if the model is usable (that is, - * even if the model has warnings or observations). + * Check if a validation reported a valid concept, returns true if the model is usable (that is, even if the model + * has warnings or observations). * * @return true, if the concept is reported as valid and can be used */ @@ -69,8 +69,7 @@ public class PfValidationResult { } /** - * Check if a validation reported a concept with no errors or warnings, returns true if the - * model is OK to use. + * Check if a validation reported a concept with no errors or warnings, returns true if the model is OK to use. * * @return true, if the concept has no warnings or errors */ @@ -78,9 +77,21 @@ public class PfValidationResult { return validationResult == ValidationResult.VALID || validationResult == ValidationResult.OBSERVATION; } + + /** + * Append a validation result to another validation result. + * + * @param result2Append the result to append to the current validation result + */ + public void append(final PfValidationResult result2Append) { + for (PfValidationMessage message : result2Append.getMessageList()) { + addValidationMessage(message); + } + } + /** - * Adds a validation message to the validation result, used by validate() implementations on - * {@link PfConcept} subclasses to report validaiton observations. + * Adds a validation message to the validation result, used by validate() implementations on {@link PfConcept} + * subclasses to report validaiton observations. * * @param validationMessage the validation message */ diff --git a/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java b/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java index d536e406f..6030d2ab9 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java @@ -1,6 +1,6 @@ /*- * ============LICENSE_START======================================================= - * Copyright (C) 2019 Nordix Foundation. + * Copyright (C) 2019-2020 Nordix Foundation. * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); @@ -35,7 +35,7 @@ public class ValidationTest { private static final String SOME_MESSAGE = "Some message"; @Test - public void test() { + public void testValidation1() { PfValidationResult result = new PfValidationResult(); PfConceptKey pfKeyey = new PfConceptKey("PK", "0.0.1"); result = pfKeyey.validate(result); @@ -47,7 +47,7 @@ public class ValidationTest { assertNotNull(result.getMessageList()); PfValidationMessage vmess0 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.VALID, SOME_MESSAGE); + ValidationResult.VALID, SOME_MESSAGE); result.addValidationMessage(vmess0); assertTrue(result.isOk()); @@ -57,7 +57,7 @@ public class ValidationTest { assertNotNull(HELLO, result.toString()); PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.OBSERVATION, SOME_MESSAGE); + ValidationResult.OBSERVATION, SOME_MESSAGE); result.addValidationMessage(vmess1); assertTrue(result.isOk()); @@ -65,9 +65,15 @@ public class ValidationTest { assertEquals(PfValidationResult.ValidationResult.OBSERVATION, result.getValidationResult()); assertNotNull(result.getMessageList()); assertNotNull(HELLO, result.toString()); + } + + + @Test + public void testValidation2() { + PfValidationResult result = new PfValidationResult(); PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.WARNING, SOME_MESSAGE); + ValidationResult.WARNING, SOME_MESSAGE); result.addValidationMessage(vmess2); assertFalse(result.isOk()); @@ -77,7 +83,7 @@ public class ValidationTest { assertNotNull(HELLO, result.toString()); PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, - ValidationResult.INVALID, SOME_MESSAGE); + ValidationResult.INVALID, SOME_MESSAGE); result.addValidationMessage(vmess3); assertFalse(result.isOk()); @@ -86,9 +92,42 @@ public class ValidationTest { assertNotNull(result.getMessageList()); assertNotNull(HELLO, result.toString()); - assertEquals(PfValidationResult.ValidationResult.INVALID, result.getMessageList().get(3).getValidationResult()); - assertEquals(SOME_MESSAGE, result.getMessageList().get(3).getMessage()); - assertEquals(PfConceptKey.class.getName(), result.getMessageList().get(3).getObservedClass()); - assertEquals(PfConceptKey.getNullKey(), result.getMessageList().get(3).getObservedKey()); + assertEquals(PfValidationResult.ValidationResult.INVALID, result.getMessageList().get(1).getValidationResult()); + assertEquals(SOME_MESSAGE, result.getMessageList().get(1).getMessage()); + assertEquals(PfConceptKey.class.getName(), result.getMessageList().get(1).getObservedClass()); + assertEquals(PfConceptKey.getNullKey(), result.getMessageList().get(1).getObservedKey()); + } + + @Test + public void testValidationAppend() { + PfValidationResult result = new PfValidationResult(); + + PfValidationResult result2 = new PfValidationResult(); + PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, + ValidationResult.OBSERVATION, "Message 1"); + result2.addValidationMessage(vmess1); + + result.append(result2); + assertEquals(1, result.getMessageList().size()); + assertEquals(ValidationResult.OBSERVATION, result.getValidationResult()); + + PfValidationResult result3 = new PfValidationResult(); + PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, + ValidationResult.WARNING, "Message 2"); + result3.addValidationMessage(vmess2); + result.append(result3); + assertEquals(2, result.getMessageList().size()); + assertEquals(ValidationResult.WARNING, result.getValidationResult()); + + PfValidationResult result4 = new PfValidationResult(); + PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, + ValidationResult.INVALID, "Message 3"); + PfValidationMessage vmess4 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class, + ValidationResult.VALID, "Message 4"); + result4.addValidationMessage(vmess3); + result4.addValidationMessage(vmess4); + result.append(result4); + assertEquals(4, result.getMessageList().size()); + assertEquals(ValidationResult.INVALID, result.getValidationResult()); } } diff --git a/models-provider/src/test/resources/META-INF/persistence.xml b/models-provider/src/test/resources/META-INF/persistence.xml index d63c415fd..b4506e569 100644 --- a/models-provider/src/test/resources/META-INF/persistence.xml +++ b/models-provider/src/test/resources/META-INF/persistence.xml @@ -23,23 +23,36 @@ org.eclipse.persistence.jpa.PersistenceProvider + org.onap.policy.models.base.PfConceptKey org.onap.policy.models.dao.converters.CDataConditioner org.onap.policy.models.dao.converters.Uuid2String - org.onap.policy.models.base.PfConceptKey + org.onap.policy.models.pdp.persistence.concepts.JpaPdp + org.onap.policy.models.pdp.persistence.concepts.JpaPdpGroup + org.onap.policy.models.pdp.persistence.concepts.JpaPdpStatistics + org.onap.policy.models.pdp.persistence.concepts.JpaPdpSubGroup + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignment + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignments + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityType + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityTypes org.onap.policy.models.tosca.simple.concepts.JpaToscaDataType org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplates + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeType + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTypes + org.onap.policy.models.tosca.simple.concepts.JpaToscaParameter org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicy org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyType org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes - org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate + org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty + org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipType + org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipTypes + org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirement + org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirements org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate + org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate org.onap.policy.models.tosca.simple.concepts.JpaToscaTrigger - org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty - org.onap.policy.models.pdp.persistence.concepts.JpaPdpGroup - org.onap.policy.models.pdp.persistence.concepts.JpaPdpSubGroup - org.onap.policy.models.pdp.persistence.concepts.JpaPdp - org.onap.policy.models.pdp.persistence.concepts.JpaPdpStatistics diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java new file mode 100644 index 000000000..63945174a --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java @@ -0,0 +1,271 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Lob; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.onap.policy.common.utils.coder.YamlJsonTranslator; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConcept; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfUtils; +import org.onap.policy.models.base.PfValidationMessage; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment; + +/** + * Class to represent the parameter in TOSCA definition. + */ +@Entity +@Table(name = "ToscaCapabilityAssignment") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@EqualsAndHashCode(callSuper = false) +public class JpaToscaCapabilityAssignment extends JpaToscaEntityType + implements PfAuthorative { + + private static final long serialVersionUID = 1675770231921107988L; + + private static final String AUTHORATIVE_UNBOUNDED_LITERAL = "UNBOUNDED"; + private static final Integer JPA_UNBOUNDED_VALUE = -1; + + private static final YamlJsonTranslator YAML_JSON_TRANSLATOR = new YamlJsonTranslator(); + + @ElementCollection + @Lob + private Map properties; + + @ElementCollection + @Lob + private Map attributes; + + @ElementCollection + private List occurrences; + + /** + * The Default Constructor creates a {@link JpaToscaCapabilityAssignment} object with a null key. + */ + public JpaToscaCapabilityAssignment() { + this(new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaCapabilityAssignment} object with the given concept key. + * + * @param key the key + */ + public JpaToscaCapabilityAssignment(@NonNull final PfConceptKey key) { + super(key); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaCapabilityAssignment(final JpaToscaCapabilityAssignment copyConcept) { + super(copyConcept); + this.properties = copyConcept.properties == null ? null : new LinkedHashMap<>(copyConcept.properties); + this.attributes = copyConcept.attributes == null ? null : new LinkedHashMap<>(copyConcept.attributes); + this.occurrences = copyConcept.occurrences == null ? null : new ArrayList<>(copyConcept.occurrences); + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaCapabilityAssignment(@NonNull final ToscaCapabilityAssignment authorativeConcept) { + super(new PfConceptKey()); + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaCapabilityAssignment toAuthorative() { + ToscaCapabilityAssignment toscaCapabilityAssignment = new ToscaCapabilityAssignment(); + super.setToscaEntity(toscaCapabilityAssignment); + super.toAuthorative(); + + toscaCapabilityAssignment.setProperties( + PfUtils.mapMap(properties, property -> YAML_JSON_TRANSLATOR.fromYaml(property, Object.class))); + + toscaCapabilityAssignment.setAttributes( + PfUtils.mapMap(attributes, attribute -> YAML_JSON_TRANSLATOR.fromYaml(attribute, Object.class))); + + toscaCapabilityAssignment.setOccurrences(PfUtils.mapList(occurrences, occurrence -> { + if (occurrence.equals(JPA_UNBOUNDED_VALUE)) { + return AUTHORATIVE_UNBOUNDED_LITERAL; + } else { + return occurrence; + } + })); + + return toscaCapabilityAssignment; + } + + @Override + public void fromAuthorative(ToscaCapabilityAssignment toscaCapabilityAssignment) { + super.fromAuthorative(toscaCapabilityAssignment); + + + properties = PfUtils.mapMap(toscaCapabilityAssignment.getProperties(), YAML_JSON_TRANSLATOR::toYaml); + attributes = PfUtils.mapMap(toscaCapabilityAssignment.getAttributes(), YAML_JSON_TRANSLATOR::toYaml); + + occurrences = PfUtils.mapList(toscaCapabilityAssignment.getOccurrences(), occurrence -> { + if (occurrence.equals(AUTHORATIVE_UNBOUNDED_LITERAL)) { + return JPA_UNBOUNDED_VALUE; + } else { + return ((Number) occurrence).intValue(); + } + }); + } + + @Override + public void clean() { + super.clean(); + + properties = PfUtils.mapMap(properties, String::trim); + attributes = PfUtils.mapMap(attributes, String::trim); + } + + @Override + public PfValidationResult validate(final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + if (properties != null) { + result.append(validateProperties(new PfValidationResult())); + } + + if (attributes != null) { + result.append(validateAttributes(new PfValidationResult())); + } + + if (occurrences != null) { + result.append(validateOccurrences(new PfValidationResult())); + } + + return result; + } + + /** + * Validate the properties. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateProperties(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (Entry propertyEntry : properties.entrySet()) { + if (propertyEntry.getValue() == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "capability assignment property " + propertyEntry.getKey() + " value may not be null")); + } + } + return result; + } + + /** + * Validate the attributes. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateAttributes(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (Entry attributeEntry : attributes.entrySet()) { + if (attributeEntry.getValue() == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "capability assignment attribute " + attributeEntry.getKey() + " value may not be null")); + } + } + return result; + } + + /** + * Validate the occurrences. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateOccurrences(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (Integer occurrence : occurrences) { + if (occurrence == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "capability assignment occurrence value may not be null ")); + } else if (occurrence < 0 && !occurrence.equals(JPA_UNBOUNDED_VALUE)) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "capability assignment occurrence value may not be negative")); + } + } + + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + + if (this == otherConcept) { + return 0; + } + + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaCapabilityAssignment other = (JpaToscaCapabilityAssignment) otherConcept; + int result = super.compareTo(other); + if (result != 0) { + return result; + } + + result = PfUtils.compareMaps(properties, other.properties); + if (result != 0) { + return result; + } + + result = PfUtils.compareMaps(attributes, other.attributes); + if (result != 0) { + return result; + } + + return PfUtils.compareCollections(occurrences, other.occurrences); + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java new file mode 100644 index 000000000..5afc89275 --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java @@ -0,0 +1,117 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import lombok.ToString; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConceptContainer; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * This class is a container for TOSCA capability assignments. + * + * @author Liam Fallon (liam.fallon@est.tech) + */ +@Entity +@Table(name = "ToscaCapabilityAssignments") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +public class JpaToscaCapabilityAssignments + extends PfConceptContainer + implements PfAuthorative>> { + public static final String DEFAULT_NAME = "ToscaCapabilityAssignmentsSimple"; + public static final String DEFAULT_VERSION = "1.0.0"; + private static final long serialVersionUID = -7526648702327776101L; + + /** + * The Default Constructor creates a {@link JpaToscaCapabilityAssignments} object with a null + * artifact key and creates an empty concept map. + */ + public JpaToscaCapabilityAssignments() { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + } + + /** + * The Key Constructor creates a {@link JpaToscaCapabilityAssignments} object with the given + * artifact key and creates an empty concept map. + * + * @param key the concept key + */ + public JpaToscaCapabilityAssignments(final PfConceptKey key) { + super(key, new TreeMap<>()); + } + + /** + * This Constructor creates an concept container with all of its fields defined. + * + * @param key the concept container key + * @param conceptMap the concepts to be stored in the concept container + */ + public JpaToscaCapabilityAssignments(final PfConceptKey key, + final Map conceptMap) { + super(key, conceptMap); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaCapabilityAssignments(final JpaToscaCapabilityAssignments copyConcept) { + super(copyConcept); + } + + /** + * Authorative constructor. + * + * @param authorativeConceptMapList the authorative concept to copy from + */ + public JpaToscaCapabilityAssignments(final List> authorativeConceptMapList) { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + this.fromAuthorative(authorativeConceptMapList); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + for (JpaToscaCapabilityAssignment assignment : this.getConceptMap().values()) { + ToscaUtils.getEntityTypeAncestors(this, assignment, result); + } + + return result; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java new file mode 100644 index 000000000..4db779557 --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java @@ -0,0 +1,239 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Lob; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.apache.commons.collections4.CollectionUtils; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConcept; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfKey; +import org.onap.policy.models.base.PfReferenceKey; +import org.onap.policy.models.base.PfUtils; +import org.onap.policy.models.base.PfValidationMessage; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType; +import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * Class to represent the capability type in TOSCA definition. + */ + +@Entity +@Table(name = "ToscaCapabilityType") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@EqualsAndHashCode(callSuper = true) +public class JpaToscaCapabilityType extends JpaToscaEntityType + implements PfAuthorative { + private static final long serialVersionUID = -563659852901842616L; + + @ElementCollection + @Lob + private Map properties; + + /** + * The Default Constructor creates a {@link JpaToscaCapabilityType} object with a null key. + */ + public JpaToscaCapabilityType() { + this(new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaCapabilityType} object with the given concept key. + * + * @param key the key + */ + public JpaToscaCapabilityType(@NonNull final PfConceptKey key) { + super(key); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaCapabilityType(final JpaToscaCapabilityType copyConcept) { + super(copyConcept); + this.properties = copyConcept.properties == null ? null : new LinkedHashMap<>(copyConcept.properties); + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaCapabilityType(final ToscaCapabilityType authorativeConcept) { + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaCapabilityType toAuthorative() { + ToscaCapabilityType toscaCapabilityType = new ToscaCapabilityType(); + super.setToscaEntity(toscaCapabilityType); + super.toAuthorative(); + + toscaCapabilityType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative)); + + return toscaCapabilityType; + } + + @Override + public void fromAuthorative(final ToscaCapabilityType toscaCapabilityType) { + super.fromAuthorative(toscaCapabilityType); + + // Set properties + if (toscaCapabilityType.getProperties() != null) { + properties = new LinkedHashMap<>(); + for (Entry toscaPropertyEntry : toscaCapabilityType.getProperties().entrySet()) { + JpaToscaProperty jpaProperty = new JpaToscaProperty(toscaPropertyEntry.getValue()); + jpaProperty.setKey(new PfReferenceKey(getKey(), toscaPropertyEntry.getKey())); + properties.put(toscaPropertyEntry.getKey(), jpaProperty); + } + } + } + + @Override + public List getKeys() { + final List keyList = super.getKeys(); + + PfUtils.mapMap(properties, property -> keyList.addAll(property.getKeys())); + + + if (properties != null) { + for (JpaToscaProperty property : properties.values()) { + keyList.addAll(property.getKeys()); + } + } + + return keyList; + } + + @Override + public void clean() { + super.clean(); + + if (properties != null) { + for (JpaToscaProperty property : properties.values()) { + property.clean(); + } + } + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + if (getKey().isNullVersion()) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "key version is a null version")); + } + + if (properties != null) { + result = validateProperties(result); + } + + return result; + } + + /** + * Validate the capabiltiy type properties. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateProperties(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (JpaToscaProperty property : properties.values()) { + if (property == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "capability type property may not be null ")); + } else { + result = property.validate(result); + } + } + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + if (this == otherConcept) { + return 0; + } + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaCapabilityType other = (JpaToscaCapabilityType) otherConcept; + int result = super.compareTo(other); + if (result != 0) { + return result; + } + + return PfUtils.compareMaps(properties, other.properties); + } + + /** + * Get the data types referenced in a capability type. + * + * @return the data types referenced in a capability type + */ + public Collection getReferencedDataTypes() { + if (properties == null) { + return CollectionUtils.emptyCollection(); + } + + Set referencedDataTypes = new LinkedHashSet<>(); + + for (JpaToscaProperty property : properties.values()) { + referencedDataTypes.add(property.getType()); + + if (property.getEntrySchema() != null) { + referencedDataTypes.add(property.getEntrySchema().getType()); + } + } + + referencedDataTypes.removeAll(ToscaUtils.getPredefinedDataTypes()); + + return referencedDataTypes; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java new file mode 100644 index 000000000..6ec6de56e --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java @@ -0,0 +1,112 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import lombok.ToString; +import org.onap.policy.models.base.PfConceptContainer; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * This class is a container for TOSCA capability types. + */ +@Entity +@Table(name = "ToscaCapabilityTypes") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +public class JpaToscaCapabilityTypes extends PfConceptContainer { + public static final String DEFAULT_NAME = "ToscaCapabilityTypesSimple"; + public static final String DEFAULT_VERSION = "1.0.0"; + private static final long serialVersionUID = -4157979965271220098L; + + /** + * The Default Constructor creates a {@link JpaToscaCapabilityTypes} object with a null artifact key and creates an + * empty concept map. + */ + public JpaToscaCapabilityTypes() { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + } + + /** + * The Key Constructor creates a {@link JpaToscaCapabilityTypes} object with the given artifact key and creates an + * empty concept map. + * + * @param key the concept key + */ + public JpaToscaCapabilityTypes(final PfConceptKey key) { + super(key, new TreeMap<>()); + } + + /** + * This Constructor creates an concept container with all of its fields defined. + * + * @param key the concept container key + * @param conceptMap the concepts to be stored in the concept container + */ + public JpaToscaCapabilityTypes(final PfConceptKey key, final Map conceptMap) { + super(key, conceptMap); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaCapabilityTypes(final JpaToscaCapabilityTypes copyConcept) { + super(copyConcept); + } + + /** + * Authorative constructor. + * + * @param authorativeConceptMapList the authorative concept to copy from + */ + public JpaToscaCapabilityTypes(final List> authorativeConceptMapList) { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + this.fromAuthorative(authorativeConceptMapList); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + // Check that all ancestors of this policy type exist + for (JpaToscaCapabilityType capabilityType : this.getConceptMap().values()) { + ToscaUtils.getEntityTypeAncestors(this, capabilityType, result); + } + + return result; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java index 4e4cb8e84..58ac9e326 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java @@ -50,7 +50,6 @@ import org.onap.policy.models.base.PfUtils; import org.onap.policy.models.base.PfValidationMessage; import org.onap.policy.models.base.PfValidationResult; import org.onap.policy.models.base.PfValidationResult.ValidationResult; -import org.onap.policy.models.tosca.authorative.concepts.ToscaConstraint; import org.onap.policy.models.tosca.authorative.concepts.ToscaDataType; import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty; import org.onap.policy.models.tosca.utils.ToscaUtils; @@ -70,11 +69,11 @@ public class JpaToscaDataType extends JpaToscaEntityType implemen private static final long serialVersionUID = -3922690413436539164L; @ElementCollection - private List constraints = new ArrayList<>(); + private List constraints; @ElementCollection @Lob - private Map properties = new LinkedHashMap<>(); + private Map properties; /** * The Default Constructor creates a {@link JpaToscaDataType} object with a null key. @@ -119,25 +118,8 @@ public class JpaToscaDataType extends JpaToscaEntityType implemen super.setToscaEntity(toscaDataType); super.toAuthorative(); - if (constraints != null) { - List toscaConstraints = new ArrayList<>(); - - for (JpaToscaConstraint constraint : constraints) { - toscaConstraints.add(constraint.toAuthorative()); - } - - toscaDataType.setConstraints(toscaConstraints); - } - - if (properties != null) { - Map propertyMap = new LinkedHashMap<>(); - - for (Entry entry : properties.entrySet()) { - propertyMap.put(entry.getKey(), entry.getValue().toAuthorative()); - } - - toscaDataType.setProperties(propertyMap); - } + toscaDataType.setConstraints(PfUtils.mapList(constraints, JpaToscaConstraint::toAuthorative)); + toscaDataType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative)); return toscaDataType; } @@ -146,13 +128,7 @@ public class JpaToscaDataType extends JpaToscaEntityType implemen public void fromAuthorative(final ToscaDataType toscaDataType) { super.fromAuthorative(toscaDataType); - if (toscaDataType.getConstraints() != null) { - constraints = new ArrayList<>(); - - for (ToscaConstraint toscaConstraint : toscaDataType.getConstraints()) { - constraints.add(JpaToscaConstraint.newInstance(toscaConstraint)); - } - } + constraints = PfUtils.mapList(toscaDataType.getConstraints(), JpaToscaConstraint::newInstance); if (toscaDataType.getProperties() != null) { properties = new LinkedHashMap<>(); @@ -220,7 +196,7 @@ public class JpaToscaDataType extends JpaToscaEntityType implemen /** * Validate the properties. * - * @param result The result of validations up to now + * @param resultIn The result of validations up to now * @return the validation result */ private PfValidationResult validateProperties(final PfValidationResult resultIn) { @@ -250,21 +226,17 @@ public class JpaToscaDataType extends JpaToscaEntityType implemen } final JpaToscaDataType other = (JpaToscaDataType) otherConcept; - if (!super.equals(other)) { - return super.compareTo(other); - } - - int result = PfUtils.compareObjects(constraints, other.constraints); + int result = super.compareTo(other); if (result != 0) { return result; } - result = PfUtils.compareObjects(properties, other.properties); + result = PfUtils.compareCollections(constraints, other.constraints); if (result != 0) { return result; } - return 0; + return PfUtils.compareMaps(properties, other.properties); } /** diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java index 76d2ff951..549d93e8a 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java @@ -21,7 +21,6 @@ package org.onap.policy.models.tosca.simple.concepts; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -70,7 +69,7 @@ public class JpaToscaEntityType extends PfConcept impleme private PfConceptKey derivedFrom; @ElementCollection - private Map metadata = new TreeMap<>(); + private Map metadata; @Column private String description; @@ -129,15 +128,7 @@ public class JpaToscaEntityType extends PfConcept impleme toscaEntity.setDescription(description); } - if (metadata != null) { - Map metadataMap = new LinkedHashMap<>(); - - for (Entry entry : metadata.entrySet()) { - metadataMap.put(entry.getKey(), entry.getValue()); - } - - toscaEntity.setMetadata(metadataMap); - } + toscaEntity.setMetadata(PfUtils.mapMap(metadata, item -> item)); return toscaEntity; } @@ -155,7 +146,7 @@ public class JpaToscaEntityType extends PfConcept impleme } if (toscaEntity.getDerivedFrom() != null) { - // CHeck if the derived from field contains a name-version ID + // Check if the derived from field contains a name-version ID if (toscaEntity.getDerivedFrom().contains(":")) { derivedFrom = new PfConceptKey(toscaEntity.getDerivedFrom()); } else { @@ -167,13 +158,7 @@ public class JpaToscaEntityType extends PfConcept impleme description = toscaEntity.getDescription(); } - if (toscaEntity.getMetadata() != null) { - metadata = new LinkedHashMap<>(); - - for (Entry metadataEntry : toscaEntity.getMetadata().entrySet()) { - metadata.put(metadataEntry.getKey(), metadataEntry.getValue()); - } - } + metadata = PfUtils.mapMap(toscaEntity.getMetadata(), item -> item); } @Override @@ -253,16 +238,18 @@ public class JpaToscaEntityType extends PfConcept impleme @SuppressWarnings("unchecked") final JpaToscaEntityType other = (JpaToscaEntityType) otherConcept; - if (!key.equals(other.key)) { - return key.compareTo(other.key); + + int result = key.compareTo(other.key); + if (result != 0) { + return result; } - int result = ObjectUtils.compare(derivedFrom, other.derivedFrom); + result = ObjectUtils.compare(derivedFrom, other.derivedFrom); if (result != 0) { return result; } - result = PfUtils.compareObjects(metadata, other.metadata); + result = PfUtils.compareMaps(metadata, other.metadata); if (result != 0) { return result; } diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java index 716813799..90bb0a89e 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java @@ -3,7 +3,7 @@ * ONAP Policy Model * ================================================================================ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. - * Modifications Copyright (C) 2019 Nordix Foundation. + * Modifications Copyright (C) 2019-2020 Nordix Foundation. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -165,19 +165,21 @@ public class JpaToscaEventFilter extends PfConcept { } final JpaToscaEventFilter other = (JpaToscaEventFilter) otherConcept; - if (!key.equals(other.key)) { - return key.compareTo(other.key); + int result = key.compareTo(other.key); + if (result != 0) { + return result; } - if (!node.equals(other.node)) { - return node.compareTo(other.node); + result = node.compareTo(other.node); + if (result != 0) { + return result; } - int result = ObjectUtils.compare(requirement, other.requirement); + result = ObjectUtils.compare(requirement, other.requirement); if (result != 0) { return result; } return ObjectUtils.compare(capability, other.capability); } -} \ No newline at end of file +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java index cc9b1bc96..d65689d8e 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java @@ -1,6 +1,6 @@ /*- * ============LICENSE_START======================================================= - * Copyright (C) 2019 Nordix Foundation. + * Copyright (C) 2019-2020 Nordix Foundation. * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); @@ -40,9 +40,8 @@ import org.onap.policy.models.base.PfModelService; import org.onap.policy.models.base.PfValidationResult; /** - * A container class for a TOSCA model with multiple service templates. This class is a container - * class that allows a model with many service templates to be constructed that contains a well - * formed overall TOSCA model. + * A container class for a TOSCA model with multiple service templates. This class is a container class that allows a + * model with many service templates to be constructed that contains a well formed overall TOSCA model. * *

Validation runs {@link JpaToscaModel} validation on the model and all its sub concepts. */ @@ -59,16 +58,16 @@ public class JpaToscaModel extends PfModel { private JpaToscaServiceTemplates serviceTemplates; /** - * The Default Constructor creates a {@link JpaToscaModel} object with a null concept key and - * creates an empty TOSCA model. + * The Default Constructor creates a {@link JpaToscaModel} object with a null concept key and creates an empty TOSCA + * model. */ public JpaToscaModel() { this(new PfConceptKey()); } /** - * The Key Constructor creates a {@link JpaToscaModel} object with the given concept key and - * creates an empty TOSCA model. + * The Key Constructor creates a {@link JpaToscaModel} object with the given concept key and creates an empty TOSCA + * model. * * @param key the TOSCA model key */ @@ -139,8 +138,9 @@ public class JpaToscaModel extends PfModel { } final JpaToscaModel other = (JpaToscaModel) otherConcept; - if (!super.equals(other)) { - return super.compareTo(other); + int result = super.compareTo(other); + if (result != 0) { + return result; } return serviceTemplates.compareTo(other.serviceTemplates); diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java new file mode 100644 index 000000000..5fccbe27a --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java @@ -0,0 +1,310 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.Lob; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import javax.ws.rs.core.Response; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.lang3.StringUtils; +import org.onap.policy.common.utils.coder.CoderException; +import org.onap.policy.common.utils.coder.StandardCoder; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConcept; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfKey; +import org.onap.policy.models.base.PfModelRuntimeException; +import org.onap.policy.models.base.PfUtils; +import org.onap.policy.models.base.PfValidationMessage; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment; +import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate; + +/** + * Class to represent the node template in TOSCA definition. + */ +@Entity +@Table(name = "ToscaNodeTemplate") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@EqualsAndHashCode(callSuper = false) +public class JpaToscaNodeTemplate extends JpaToscaEntityType + implements PfAuthorative { + private static final long serialVersionUID = 1675770231921107988L; + + private static final StandardCoder STANDARD_CODER = new StandardCoder(); + + @Column + private String type; + + @ElementCollection + @Lob + private Map properties; + + // formatter:off + @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true) + @JoinColumns({@JoinColumn(name = "requirementsName", referencedColumnName = "name"), + @JoinColumn(name = "requirementsVersion", referencedColumnName = "version")}) + private JpaToscaRequirements requirements; + + @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true) + @JoinColumns({@JoinColumn(name = "capabilitiesName", referencedColumnName = "name"), + @JoinColumn(name = "capabilitiesVersion", referencedColumnName = "version")}) + private JpaToscaCapabilityAssignments capabilities; + // @formatter:on + + /** + * The Default Constructor creates a {@link JpaToscaNodeTemplate} object with a null key. + */ + public JpaToscaNodeTemplate() { + this(new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaNodeTemplate} object with the given concept key. + * + * @param key the key + */ + public JpaToscaNodeTemplate(@NonNull final PfConceptKey key) { + this(key, null); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaNodeTemplate(final JpaToscaNodeTemplate copyConcept) { + super(copyConcept); + this.type = copyConcept.type; + this.properties = PfUtils.mapMap(copyConcept.properties, String::new); + this.requirements = + (copyConcept.requirements != null ? new JpaToscaRequirements(copyConcept.requirements) : null); + this.capabilities = + (copyConcept.capabilities != null ? new JpaToscaCapabilityAssignments(copyConcept.capabilities) : null); + } + + /** + * The Key Constructor creates a {@link JpaToscaParameter} object with the given concept key. + * + * @param key the key + * @param type the node template type + */ + public JpaToscaNodeTemplate(@NonNull final PfConceptKey key, final String type) { + super(key); + this.type = type; + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaNodeTemplate(final ToscaNodeTemplate authorativeConcept) { + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaNodeTemplate toAuthorative() { + ToscaNodeTemplate toscaNodeTemplate = new ToscaNodeTemplate(); + super.setToscaEntity(toscaNodeTemplate); + super.toAuthorative(); + + toscaNodeTemplate.setType(type); + + toscaNodeTemplate.setProperties(PfUtils.mapMap(properties, property -> { + try { + return STANDARD_CODER.decode(property, Object.class); + } catch (CoderException ce) { + String errorMessage = "error decoding property JSON value read from database: " + property; + throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce); + } + })); + + if (requirements != null) { + toscaNodeTemplate.setRequirements(requirements.toAuthorative()); + } + + if (capabilities != null) { + toscaNodeTemplate.setCapabilities(new LinkedHashMap<>()); + List> capabilityAssignmentMapList = capabilities.toAuthorative(); + for (Map capabilityAssignmentMap : capabilityAssignmentMapList) { + toscaNodeTemplate.getCapabilities().putAll(capabilityAssignmentMap); + } + } + + return toscaNodeTemplate; + } + + @Override + public void fromAuthorative(ToscaNodeTemplate toscaNodeTemplate) { + super.fromAuthorative(toscaNodeTemplate); + + type = toscaNodeTemplate.getType(); + + properties = PfUtils.mapMap(toscaNodeTemplate.getProperties(), property -> { + try { + return STANDARD_CODER.encode(property); + } catch (CoderException ce) { + String errorMessage = "error encoding property JSON value for database: " + property; + throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce); + } + }); + + if (toscaNodeTemplate.getRequirements() != null) { + requirements = new JpaToscaRequirements(); + requirements.fromAuthorative(toscaNodeTemplate.getRequirements()); + } + + if (toscaNodeTemplate.getCapabilities() != null) { + capabilities = new JpaToscaCapabilityAssignments(); + capabilities.fromAuthorative(Collections.singletonList(toscaNodeTemplate.getCapabilities())); + } + } + + @Override + public List getKeys() { + final List keyList = super.getKeys(); + + if (requirements != null) { + keyList.addAll(requirements.getKeys()); + } + + if (capabilities != null) { + keyList.addAll(capabilities.getKeys()); + } + + return keyList; + } + + @Override + public void clean() { + super.clean(); + + type = type.trim(); + + properties = PfUtils.mapMap(properties, String::trim); + + if (requirements != null) { + requirements.clean(); + } + + if (capabilities != null) { + capabilities.clean(); + } + } + + @Override + public PfValidationResult validate(final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + if (StringUtils.isBlank(type)) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "node template type may not be null")); + } + + if (properties != null) { + result.append(validateProperties(new PfValidationResult())); + } + + if (requirements != null) { + result.append(requirements.validate(result)); + } + + if (capabilities != null) { + result.append(validateProperties(capabilities.validate(result))); + } + + return result; + } + + /** + * Validate the properties. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateProperties(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (String property : properties.values()) { + if (property == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "topology template property may not be null ")); + } + } + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + if (this == otherConcept) { + return 0; + } + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaNodeTemplate other = (JpaToscaNodeTemplate) otherConcept; + int result = super.compareTo(other); + if (result != 0) { + return result; + } + + result = type.compareTo(other.type); + if (result != 0) { + return result; + } + + result = PfUtils.compareMaps(properties, other.properties); + if (result != 0) { + return result; + } + + result = ObjectUtils.compare(requirements, other.requirements); + if (result != 0) { + return result; + } + + return ObjectUtils.compare(capabilities, other.capabilities); + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java new file mode 100644 index 000000000..6c83f67c5 --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java @@ -0,0 +1,112 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import lombok.ToString; +import org.onap.policy.models.base.PfConceptContainer; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * This class is a container for TOSCA node templates. + */ +@Entity +@Table(name = "ToscaNodeTemplates") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +public class JpaToscaNodeTemplates extends PfConceptContainer { + public static final String DEFAULT_NAME = "ToscaNodeTemplatesSimple"; + public static final String DEFAULT_VERSION = "1.0.0"; + private static final long serialVersionUID = -4157979965271220098L; + + /** + * The Default Constructor creates a {@link JpaToscaNodeTemplates} object with a null artifact key and creates an + * empty concept map. + */ + public JpaToscaNodeTemplates() { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + } + + /** + * The Key Constructor creates a {@link JpaToscaNodeTemplates} object with the given artifact key and creates an + * empty concept map. + * + * @param key the concept key + */ + public JpaToscaNodeTemplates(final PfConceptKey key) { + super(key, new TreeMap<>()); + } + + /** + * This Constructor creates an concept container with all of its fields defined. + * + * @param key the concept container key + * @param conceptMap the concepts to be stored in the concept container + */ + public JpaToscaNodeTemplates(final PfConceptKey key, final Map conceptMap) { + super(key, conceptMap); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaNodeTemplates(final JpaToscaNodeTemplates copyConcept) { + super(copyConcept); + } + + /** + * Authorative constructor. + * + * @param authorativeConceptMapList the authorative concept to copy from + */ + public JpaToscaNodeTemplates(final List> authorativeConceptMapList) { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + this.fromAuthorative(authorativeConceptMapList); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + // Check that all ancestors of this node template exist + for (JpaToscaNodeTemplate nodeTemplate : this.getConceptMap().values()) { + ToscaUtils.getEntityTypeAncestors(this, nodeTemplate, result); + } + + return result; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java new file mode 100644 index 000000000..26684b583 --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java @@ -0,0 +1,277 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import javax.persistence.CascadeType; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.JoinColumn; +import javax.persistence.JoinColumns; +import javax.persistence.Lob; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.ObjectUtils; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConcept; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfKey; +import org.onap.policy.models.base.PfReferenceKey; +import org.onap.policy.models.base.PfUtils; +import org.onap.policy.models.base.PfValidationMessage; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType; +import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * Class to represent the node type in TOSCA definition. + */ + +@Entity +@Table(name = "ToscaNodeType") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@EqualsAndHashCode(callSuper = true) +public class JpaToscaNodeType extends JpaToscaEntityType implements PfAuthorative { + private static final long serialVersionUID = -563659852901842616L; + + @ElementCollection + @Lob + private Map properties; + + + // formatter:off + @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true) + @JoinColumns({@JoinColumn(name = "requirementsName", referencedColumnName = "name"), + @JoinColumn(name = "requirementsVersion", referencedColumnName = "version")}) + // @formatter:on + private JpaToscaRequirements requirements; + + /** + * The Default Constructor creates a {@link JpaToscaNodeType} object with a null key. + */ + public JpaToscaNodeType() { + this(new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaNodeType} object with the given concept key. + * + * @param key the key + */ + public JpaToscaNodeType(@NonNull final PfConceptKey key) { + super(key); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaNodeType(final JpaToscaNodeType copyConcept) { + super(copyConcept); + this.properties = PfUtils.mapMap(copyConcept.properties, JpaToscaProperty::new); + this.requirements = + (copyConcept.requirements != null ? new JpaToscaRequirements(copyConcept.requirements) : null); + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaNodeType(final ToscaNodeType authorativeConcept) { + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaNodeType toAuthorative() { + ToscaNodeType toscaNodeType = new ToscaNodeType(); + super.setToscaEntity(toscaNodeType); + super.toAuthorative(); + + toscaNodeType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative)); + + if (requirements != null) { + toscaNodeType.setRequirements(requirements.toAuthorative()); + } + + return toscaNodeType; + } + + @Override + public void fromAuthorative(final ToscaNodeType toscaNodeType) { + super.fromAuthorative(toscaNodeType); + + // Set properties + if (toscaNodeType.getProperties() != null) { + properties = new LinkedHashMap<>(); + for (Entry toscaPropertyEntry : toscaNodeType.getProperties().entrySet()) { + JpaToscaProperty jpaProperty = new JpaToscaProperty(toscaPropertyEntry.getValue()); + jpaProperty.setKey(new PfReferenceKey(getKey(), toscaPropertyEntry.getKey())); + properties.put(toscaPropertyEntry.getKey(), jpaProperty); + } + } + + if (toscaNodeType.getRequirements() != null) { + requirements = new JpaToscaRequirements(); + requirements.fromAuthorative(toscaNodeType.getRequirements()); + } + } + + @Override + public List getKeys() { + final List keyList = super.getKeys(); + + if (properties != null) { + for (JpaToscaProperty property : properties.values()) { + keyList.addAll(property.getKeys()); + } + } + + if (requirements != null) { + keyList.addAll(requirements.getKeys()); + } + + return keyList; + } + + @Override + public void clean() { + super.clean(); + + if (properties != null) { + for (JpaToscaProperty property : properties.values()) { + property.clean(); + } + } + + if (requirements != null) { + requirements.clean(); + } + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + if (PfKey.NULL_KEY_VERSION.equals(getKey().getVersion())) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "key version is a null version")); + } + + if (properties != null) { + result = validateProperties(result); + } + + if (requirements != null) { + result = requirements.validate(result); + } + + return result; + } + + /** + * Validate the capabiltiy type properties. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateProperties(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (JpaToscaProperty property : properties.values()) { + if (property == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "node type property may not be null ")); + } else { + result = property.validate(result); + } + } + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + if (this == otherConcept) { + return 0; + } + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaNodeType other = (JpaToscaNodeType) otherConcept; + int result = super.compareTo(other); + if (result != 0) { + return result; + } + + result = PfUtils.compareMaps(properties, other.properties); + if (result != 0) { + return result; + } + + return ObjectUtils.compare(requirements, other.requirements); + } + + /** + * Get the data types referenced in a node type. + * + * @return the data types referenced in a node type + */ + public Collection getReferencedDataTypes() { + if (properties == null) { + return CollectionUtils.emptyCollection(); + } + + Set referencedDataTypes = new LinkedHashSet<>(); + + for (JpaToscaProperty property : properties.values()) { + referencedDataTypes.add(property.getType()); + + if (property.getEntrySchema() != null) { + referencedDataTypes.add(property.getEntrySchema().getType()); + } + } + + referencedDataTypes.removeAll(ToscaUtils.getPredefinedDataTypes()); + + return referencedDataTypes; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java new file mode 100644 index 000000000..5eb5a2c49 --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java @@ -0,0 +1,112 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import lombok.ToString; +import org.onap.policy.models.base.PfConceptContainer; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * This class is a container for TOSCA node types. + */ +@Entity +@Table(name = "ToscaNodeTypes") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +public class JpaToscaNodeTypes extends PfConceptContainer { + public static final String DEFAULT_NAME = "ToscaNodeTypesSimple"; + public static final String DEFAULT_VERSION = "1.0.0"; + private static final long serialVersionUID = -4157979965271220098L; + + /** + * The Default Constructor creates a {@link JpaToscaNodeTypes} object with a null artifact key and creates an + * empty concept map. + */ + public JpaToscaNodeTypes() { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + } + + /** + * The Key Constructor creates a {@link JpaToscaNodeTypes} object with the given artifact key and creates an + * empty concept map. + * + * @param key the concept key + */ + public JpaToscaNodeTypes(final PfConceptKey key) { + super(key, new TreeMap<>()); + } + + /** + * This Constructor creates an concept container with all of its fields defined. + * + * @param key the concept container key + * @param conceptMap the concepts to be stored in the concept container + */ + public JpaToscaNodeTypes(final PfConceptKey key, final Map conceptMap) { + super(key, conceptMap); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaNodeTypes(final JpaToscaNodeTypes copyConcept) { + super(copyConcept); + } + + /** + * Authorative constructor. + * + * @param authorativeConceptMapList the authorative concept to copy from + */ + public JpaToscaNodeTypes(final List> authorativeConceptMapList) { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + this.fromAuthorative(authorativeConceptMapList); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + // Check that all ancestors of this policy type exist + for (JpaToscaNodeType nodeType : this.getConceptMap().values()) { + ToscaUtils.getEntityTypeAncestors(this, nodeType, result); + } + + return result; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java new file mode 100644 index 000000000..216e877cc --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java @@ -0,0 +1,202 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import javax.persistence.Column; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.apache.commons.lang3.StringUtils; +import org.onap.policy.common.utils.coder.YamlJsonTranslator; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConcept; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfKey; +import org.onap.policy.models.base.PfReferenceKey; +import org.onap.policy.models.base.PfValidationMessage; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaParameter; + +/** + * Class to represent the parameter in TOSCA definition. + */ +@Entity +@Table(name = "ToscaParameter") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@EqualsAndHashCode(callSuper = false) +public class JpaToscaParameter extends PfConcept implements PfAuthorative { + private static final long serialVersionUID = 1675770231921107988L; + + @EmbeddedId + private PfReferenceKey key; + + @Column + private PfConceptKey type; + + @Column + private String value; + + /** + * The Default Constructor creates a {@link JpaToscaParameter} object with a null key. + */ + public JpaToscaParameter() { + this(new PfReferenceKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaParameter} object with the given concept key. + * + * @param key the key + */ + public JpaToscaParameter(@NonNull final PfReferenceKey key) { + this(key, new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaParameter} object with the given concept key. + * + * @param key the key + * @param type the key of the parameter type + */ + public JpaToscaParameter(@NonNull final PfReferenceKey key, @NonNull final PfConceptKey type) { + this.key = key; + this.type = type; + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaParameter(final JpaToscaParameter copyConcept) { + super(copyConcept); + this.key = new PfReferenceKey(copyConcept.key); + this.type = new PfConceptKey(copyConcept.type); + this.value = copyConcept.value; + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaParameter(final ToscaParameter authorativeConcept) { + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaParameter toAuthorative() { + ToscaParameter toscaParameter = new ToscaParameter(); + + toscaParameter.setName(key.getLocalName()); + + toscaParameter.setType(type.getName()); + toscaParameter.setTypeVersion(type.getVersion()); + + if (!StringUtils.isBlank(value)) { + toscaParameter.setValue(new YamlJsonTranslator().fromYaml(value, Object.class)); + } + + return toscaParameter; + } + + @Override + public void fromAuthorative(ToscaParameter toscaParameter) { + this.setKey(new PfReferenceKey()); + getKey().setLocalName(toscaParameter.getName()); + + if (toscaParameter.getTypeVersion() != null) { + type = new PfConceptKey(toscaParameter.getType(), toscaParameter.getTypeVersion()); + } else { + type = new PfConceptKey(toscaParameter.getType(), PfKey.NULL_KEY_VERSION); + } + + value = new YamlJsonTranslator().toYaml(toscaParameter.getValue()); + } + + @Override + public List getKeys() { + final List keyList = getKey().getKeys(); + + keyList.addAll(type.getKeys()); + + return keyList; + } + + @Override + public void clean() { + key.clean(); + + type.clean(); + + if (value != null) { + value = value.trim(); + } + } + + @Override + public PfValidationResult validate(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + if (key.isNullKey()) { + result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, + "paremeter key is a null key")); + } + + result = key.validate(result); + + if (type == null || type.isNullKey()) { + result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, + "parameter type may not be null")); + } + + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + if (this == otherConcept) { + return 0; + } + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaParameter other = (JpaToscaParameter) otherConcept; + int result = key.compareTo(other.key); + if (result != 0) { + return result; + } + + return value.compareTo(other.value); + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java index 689d03506..518a0884b 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java @@ -23,7 +23,6 @@ package org.onap.policy.models.tosca.simple.concepts; -import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -73,6 +72,8 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P private static final String METADATA_POLICY_ID_TAG = "policy-id"; private static final String METADATA_POLICY_VERSION_TAG = "policy-version"; + private static final StandardCoder STANDARD_CODER = new StandardCoder(); + // @formatter:off @Column @AttributeOverrides({ @@ -85,10 +86,10 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P @ElementCollection @Lob - private Map properties = new LinkedHashMap<>(); + private Map properties; @ElementCollection - private List targets = new ArrayList<>(); + private List targets; // @formatter:on /** @@ -155,28 +156,14 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P toscaPolicy.setTypeVersion(null); } - if (properties != null) { - Map propertyMap = new LinkedHashMap<>(); - - final StandardCoder coder = new StandardCoder(); - - for (Entry entry : properties.entrySet()) { - try { - // TODO: This is a HACK, we need to validate the properties against their - // TODO: their data type in their policy type definition in TOSCA, which means reading - // TODO: the policy type from the database and parsing the property value object correctly - // TODO: Here we are simply reading a JSON string from the database and deserializing the - // TODO: property value from JSON - propertyMap.put(entry.getKey(), coder.decode(entry.getValue(), Object.class)); - } catch (CoderException ce) { - String errorMessage = "error decoding property JSON value read from database: key=" + entry.getKey() - + ", value=" + entry.getValue(); - throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce); - } + toscaPolicy.setProperties(PfUtils.mapMap(properties, property -> { + try { + return STANDARD_CODER.decode(property, Object.class); + } catch (CoderException ce) { + String errorMessage = "error decoding property JSON value read from database: " + property; + throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce); } - - toscaPolicy.setProperties(propertyMap); - } + })); return toscaPolicy; } @@ -189,38 +176,26 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P type.setName(toscaPolicy.getType()); } else { throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, - "PolicyType type not specified, the type of the PolicyType for this policy must be specified in " - + "the type field"); + "PolicyType type not specified, the type of the PolicyType for this policy must be specified in " + + "the type field"); } if (toscaPolicy.getTypeVersion() != null) { type.setVersion(toscaPolicy.getTypeVersion()); } else { throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, - "PolicyType version not specified, the version of the PolicyType for this policy must be specified in " - + "the type_version field"); + "PolicyType version not specified, the version of the PolicyType for this policy must be specified" + + " in the type_version field"); } - if (toscaPolicy.getProperties() != null) { - properties = new LinkedHashMap<>(); - - final StandardCoder coder = new StandardCoder(); - - for (Entry propertyEntry : toscaPolicy.getProperties().entrySet()) { - // TODO: This is a HACK, we need to validate the properties against their - // TODO: their data type in their policy type definition in TOSCA, which means reading - // TODO: the policy type from the database and parsing the property value object correctly - // TODO: Here we are simply serializing the property value into a string and storing it - // TODO: unvalidated into the database - try { - properties.put(propertyEntry.getKey(), coder.encode(propertyEntry.getValue())); - } catch (CoderException ce) { - String errorMessage = "error encoding property JSON value for database: key=" - + propertyEntry.getKey() + ", value=" + propertyEntry.getValue(); - throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce); - } + properties = PfUtils.mapMap(toscaPolicy.getProperties(), property -> { + try { + return STANDARD_CODER.encode(property); + } catch (CoderException ce) { + String errorMessage = "error encoding property JSON value for database: " + property; + throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce); } - } + }); // Add the property metadata if it doesn't exist already if (toscaPolicy.getMetadata() == null) { @@ -264,12 +239,12 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P if (PfKey.NULL_KEY_VERSION.equals(getKey().getVersion())) { result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, - "key version is a null version")); + "key version is a null version")); } if (type == null || type.isNullKey()) { result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, - "type is null or a null key")); + "type is null or a null key")); } else { result = type.validate(result); } @@ -295,10 +270,10 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P for (Entry propertyEntry : properties.entrySet()) { if (!ParameterValidationUtils.validateStringParameter(propertyEntry.getKey())) { result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, - "policy property key may not be null ")); + "policy property key may not be null ")); } else if (propertyEntry.getValue() == null) { result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, - "policy property value may not be null ")); + "policy property value may not be null ")); } } } @@ -306,7 +281,7 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P /** * Validate the policy targets. * - * @param result The result of validations up to now + * @param resultIn The result of validations up to now * @return the validation result */ private PfValidationResult validateTargets(final PfValidationResult resultIn) { @@ -315,7 +290,7 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P for (PfConceptKey target : targets) { if (target == null) { result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, - "policy target may not be null ")); + "policy target may not be null ")); } else { result = target.validate(result); } @@ -338,19 +313,21 @@ public class JpaToscaPolicy extends JpaToscaEntityType implements P } final JpaToscaPolicy other = (JpaToscaPolicy) otherConcept; - if (!super.equals(other)) { - return super.compareTo(other); + int result = super.compareTo(other); + if (result != 0) { + return result; } - if (!type.equals(other.type)) { - return type.compareTo(other.type); + result = type.compareTo(other.type); + if (result != 0) { + return result; } - int retVal = PfUtils.compareObjects(properties, other.properties); - if (retVal != 0) { - return retVal; + result = PfUtils.compareMaps(properties, other.properties); + if (result != 0) { + return result; } - return PfUtils.compareObjects(targets, other.targets); + return PfUtils.compareCollections(targets, other.targets); } } diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java index 93bfd2a94..7a5493ce1 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java @@ -23,7 +23,6 @@ package org.onap.policy.models.tosca.simple.concepts; -import java.util.ArrayList; import java.util.Collection; import java.util.LinkedHashMap; import java.util.LinkedHashSet; @@ -71,13 +70,13 @@ public class JpaToscaPolicyType extends JpaToscaEntityType impl @ElementCollection @Lob - private Map properties = new LinkedHashMap<>(); + private Map properties; @ElementCollection - private List targets = new ArrayList<>(); + private List targets; @ElementCollection - private List triggers = new ArrayList<>(); + private List triggers; /** * The Default Constructor creates a {@link JpaToscaPolicyType} object with a null key. @@ -122,15 +121,7 @@ public class JpaToscaPolicyType extends JpaToscaEntityType impl super.setToscaEntity(toscaPolicyType); super.toAuthorative(); - if (properties != null) { - Map propertyMap = new LinkedHashMap<>(); - - for (Entry entry : properties.entrySet()) { - propertyMap.put(entry.getKey(), entry.getValue().toAuthorative()); - } - - toscaPolicyType.setProperties(propertyMap); - } + toscaPolicyType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative)); return toscaPolicyType; } @@ -293,21 +284,22 @@ public class JpaToscaPolicyType extends JpaToscaEntityType impl } final JpaToscaPolicyType other = (JpaToscaPolicyType) otherConcept; - if (!super.equals(other)) { - return super.compareTo(other); + int result = super.compareTo(other); + if (result != 0) { + return result; } - int retVal = PfUtils.compareObjects(properties, other.properties); - if (retVal != 0) { - return retVal; + result = PfUtils.compareMaps(properties, other.properties); + if (result != 0) { + return result; } - retVal = PfUtils.compareObjects(targets, other.targets); - if (retVal != 0) { - return retVal; + result = PfUtils.compareCollections(targets, other.targets); + if (result != 0) { + return result; } - return PfUtils.compareObjects(triggers, other.triggers); + return PfUtils.compareCollections(triggers, other.triggers); } /** diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java index 48ee9d4a2..c56dc6a42 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java @@ -27,7 +27,6 @@ import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import javax.persistence.Column; import javax.persistence.ElementCollection; import javax.persistence.EmbeddedId; @@ -49,7 +48,6 @@ import org.onap.policy.models.base.PfUtils; import org.onap.policy.models.base.PfValidationMessage; import org.onap.policy.models.base.PfValidationResult; import org.onap.policy.models.base.PfValidationResult.ValidationResult; -import org.onap.policy.models.tosca.authorative.concepts.ToscaConstraint; import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty; import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty.Status; @@ -86,13 +84,13 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative constraints = new ArrayList<>(); + private List constraints; @Column - private JpaToscaEntrySchema entrySchema; + private JpaToscaSchemaDefinition entrySchema; @ElementCollection - private Map metadata = new LinkedHashMap<>(); + private Map metadata; /** * The Default Constructor creates a {@link JpaToscaProperty} object with a null key. @@ -113,7 +111,7 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative(copyConcept.constraints) : null); - this.entrySchema = (copyConcept.entrySchema != null ? new JpaToscaEntrySchema(copyConcept.entrySchema) : null); + this.entrySchema = + (copyConcept.entrySchema != null ? new JpaToscaSchemaDefinition(copyConcept.entrySchema) : null); this.metadata = (copyConcept.metadata != null ? new LinkedHashMap<>(copyConcept.metadata) : null); } @@ -166,23 +165,13 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative toscaConstraints = new ArrayList<>(); - - for (JpaToscaConstraint constraint : constraints) { - toscaConstraints.add(constraint.toAuthorative()); - } - - toscaProperty.setConstraints(toscaConstraints); - } + toscaProperty.setConstraints(PfUtils.mapList(constraints, JpaToscaConstraint::toAuthorative)); if (entrySchema != null) { toscaProperty.setEntrySchema(entrySchema.toAuthorative()); } - if (metadata != null) { - toscaProperty.setMetadata(new LinkedHashMap<>(metadata)); - } + toscaProperty.setMetadata(PfUtils.mapMap(metadata, metadataItem -> metadataItem)); return toscaProperty; } @@ -208,23 +197,13 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative(); - - for (ToscaConstraint toscaConstraint : toscaProperty.getConstraints()) { - constraints.add(JpaToscaConstraint.newInstance(toscaConstraint)); - } - } + constraints = PfUtils.mapList(toscaProperty.getConstraints(), JpaToscaConstraint::newInstance); if (toscaProperty.getEntrySchema() != null) { - entrySchema = new JpaToscaEntrySchema(toscaProperty.getEntrySchema()); - } - - // Add the property metadata if it doesn't exist already - if (toscaProperty.getMetadata() != null) { - metadata = new LinkedHashMap<>(toscaProperty.getMetadata()); + entrySchema = new JpaToscaSchemaDefinition(toscaProperty.getEntrySchema()); } + metadata = PfUtils.mapMap(toscaProperty.getMetadata(), metadataItem -> metadataItem); } @Override @@ -258,11 +237,7 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative metadataEntry : metadata.entrySet()) { - metadataEntry.setValue(metadataEntry.getValue().trim()); - } - } + metadata = PfUtils.mapMap(metadata, String::trim); } @Override @@ -271,14 +246,14 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative + implements PfAuthorative { + private static final long serialVersionUID = -563659852901842616L; + + @ElementCollection + @Lob + private Map properties; + + /** + * The Default Constructor creates a {@link JpaToscaRelationshipType} object with a null key. + */ + public JpaToscaRelationshipType() { + this(new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaRelationshipType} object with the given concept key. + * + * @param key the key + */ + public JpaToscaRelationshipType(@NonNull final PfConceptKey key) { + super(key); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaRelationshipType(final JpaToscaRelationshipType copyConcept) { + super(copyConcept); + this.properties = PfUtils.mapMap(copyConcept.properties, JpaToscaProperty::new); + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaRelationshipType(final ToscaRelationshipType authorativeConcept) { + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaRelationshipType toAuthorative() { + ToscaRelationshipType toscaRelationshipType = new ToscaRelationshipType(); + super.setToscaEntity(toscaRelationshipType); + super.toAuthorative(); + + toscaRelationshipType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative)); + + return toscaRelationshipType; + } + + @Override + public void fromAuthorative(final ToscaRelationshipType toscaRelationshipType) { + super.fromAuthorative(toscaRelationshipType); + + // Set properties + if (toscaRelationshipType.getProperties() != null) { + properties = new LinkedHashMap<>(); + for (Entry toscaPropertyEntry : toscaRelationshipType.getProperties().entrySet()) { + JpaToscaProperty jpaProperty = new JpaToscaProperty(toscaPropertyEntry.getValue()); + jpaProperty.setKey(new PfReferenceKey(getKey(), toscaPropertyEntry.getKey())); + properties.put(toscaPropertyEntry.getKey(), jpaProperty); + } + } + } + + @Override + public List getKeys() { + final List keyList = super.getKeys(); + + if (properties != null) { + for (JpaToscaProperty property : properties.values()) { + keyList.addAll(property.getKeys()); + } + } + + return keyList; + } + + @Override + public void clean() { + super.clean(); + + if (properties != null) { + for (JpaToscaProperty property : properties.values()) { + property.clean(); + } + } + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + if (PfKey.NULL_KEY_VERSION.equals(getKey().getVersion())) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "key version is a null version")); + } + + if (properties != null) { + result = validateProperties(result); + } + + return result; + } + + /** + * Validate the capabiltiy type properties. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateProperties(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (JpaToscaProperty property : properties.values()) { + if (property == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "relationship type property may not be null ")); + } else { + result = property.validate(result); + } + } + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + if (this == otherConcept) { + return 0; + } + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaRelationshipType other = (JpaToscaRelationshipType) otherConcept; + int result = super.compareTo(other); + if (result != 0) { + return result; + } + + return PfUtils.compareMaps(properties, other.properties); + } + + /** + * Get the data types referenced in a relationship type. + * + * @return the data types referenced in a relationship type + */ + public Collection getReferencedDataTypes() { + if (properties == null) { + return CollectionUtils.emptyCollection(); + } + + Set referencedDataTypes = new LinkedHashSet<>(); + + for (JpaToscaProperty property : properties.values()) { + referencedDataTypes.add(property.getType()); + + if (property.getEntrySchema() != null) { + referencedDataTypes.add(property.getEntrySchema().getType()); + } + } + + referencedDataTypes.removeAll(ToscaUtils.getPredefinedDataTypes()); + + return referencedDataTypes; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java new file mode 100644 index 000000000..28e1d602c --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java @@ -0,0 +1,113 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import lombok.ToString; +import org.onap.policy.models.base.PfConceptContainer; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaRelationshipType; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * This class is a container for TOSCA relationship types. + */ +@Entity +@Table(name = "ToscaRelationshipTypes") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +public class JpaToscaRelationshipTypes extends PfConceptContainer { + public static final String DEFAULT_NAME = "ToscaRelationshipTypesSimple"; + public static final String DEFAULT_VERSION = "1.0.0"; + private static final long serialVersionUID = -4157979965271220098L; + + /** + * The Default Constructor creates a {@link JpaToscaRelationshipTypes} object with a null artifact key and creates + * an empty concept map. + */ + public JpaToscaRelationshipTypes() { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + } + + /** + * The Key Constructor creates a {@link JpaToscaRelationshipTypes} object with the given artifact key and creates an + * empty concept map. + * + * @param key the concept key + */ + public JpaToscaRelationshipTypes(final PfConceptKey key) { + super(key, new TreeMap<>()); + } + + /** + * This Constructor creates an concept container with all of its fields defined. + * + * @param key the concept container key + * @param conceptMap the concepts to be stored in the concept container + */ + public JpaToscaRelationshipTypes(final PfConceptKey key, + final Map conceptMap) { + super(key, conceptMap); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaRelationshipTypes(final JpaToscaRelationshipTypes copyConcept) { + super(copyConcept); + } + + /** + * Authorative constructor. + * + * @param authorativeConceptMapList the authorative concept to copy from + */ + public JpaToscaRelationshipTypes(final List> authorativeConceptMapList) { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + this.fromAuthorative(authorativeConceptMapList); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + // Check that all ancestors of this policy type exist + for (JpaToscaRelationshipType relationshipType : this.getConceptMap().values()) { + ToscaUtils.getEntityTypeAncestors(this, relationshipType, result); + } + + return result; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java new file mode 100644 index 000000000..aebc31caf --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java @@ -0,0 +1,303 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP Requirement Model + * ================================================================================ + * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved. + * Modifications Copyright (C) 2019-2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Lob; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import org.onap.policy.common.utils.coder.YamlJsonTranslator; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConcept; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfKey; +import org.onap.policy.models.base.PfUtils; +import org.onap.policy.models.base.PfValidationMessage; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaRequirement; + +/** + * Class to represent the requirement in TOSCA definition. + * + * @author Chenfei Gao (cgao@research.att.com) + * @author Liam Fallon (liam.fallon@est.tech) + */ +@Entity +@Table(name = "ToscaRequirement") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@EqualsAndHashCode(callSuper = true) +public class JpaToscaRequirement extends JpaToscaEntityType + implements PfAuthorative { + + private static final long serialVersionUID = 2785481541573683089L; + private static final String AUTHORATIVE_UNBOUNDED_LITERAL = "UNBOUNDED"; + private static final Double JPA_UNBOUNDED_VALUE = -1.0; + + @Column + private String capability; + + @Column + private String node; + + @Column + private String relationship; + + @ElementCollection + private List occurrences; + + @ElementCollection + @Lob + private Map properties; + + /** + * The Default Constructor creates a {@link JpaToscaRequirement} object with a null key. + */ + public JpaToscaRequirement() { + this(new PfConceptKey()); + } + + /** + * The Key Constructor creates a {@link JpaToscaRequirement} object with the given concept key. + * + * @param key the key + */ + public JpaToscaRequirement(@NonNull final PfConceptKey key) { + super(key); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaRequirement(@NonNull final JpaToscaRequirement copyConcept) { + super(copyConcept); + this.capability = copyConcept.capability; + this.node = copyConcept.node; + this.relationship = copyConcept.relationship; + this.occurrences = new ArrayList<>(copyConcept.occurrences); + this.properties = PfUtils.mapMap(copyConcept.properties, String::new); + } + + /** + * Authorative constructor. + * + * @param authorativeConcept the authorative concept to copy from + */ + public JpaToscaRequirement(final ToscaRequirement authorativeConcept) { + super(new PfConceptKey()); + this.fromAuthorative(authorativeConcept); + } + + @Override + public ToscaRequirement toAuthorative() { + ToscaRequirement toscaRequirement = new ToscaRequirement(); + super.setToscaEntity(toscaRequirement); + super.toAuthorative(); + + toscaRequirement.setCapability(capability); + toscaRequirement.setNode(node); + toscaRequirement.setRelationship(relationship); + + if (occurrences != null) { + List occurrencesList = new ArrayList<>(occurrences); + for (Double occurrence : occurrences) { + if (occurrence == JPA_UNBOUNDED_VALUE) { + occurrencesList.add(AUTHORATIVE_UNBOUNDED_LITERAL); + } else { + occurrencesList.add(occurrence.doubleValue()); + } + } + toscaRequirement.setOccurrences(occurrencesList); + } + + if (properties != null) { + Map propertiesMap = new LinkedHashMap<>(); + + for (Map.Entry entry : properties.entrySet()) { + propertiesMap.put(entry.getKey(), new YamlJsonTranslator().fromYaml(entry.getValue(), Object.class)); + } + + toscaRequirement.setProperties(propertiesMap); + } + + return toscaRequirement; + } + + @Override + public void fromAuthorative(@NonNull final ToscaRequirement toscaRequirement) { + super.fromAuthorative(toscaRequirement); + + capability = toscaRequirement.getCapability(); + node = toscaRequirement.getNode(); + relationship = toscaRequirement.getRelationship(); + + if (toscaRequirement.getOccurrences() != null) { + occurrences = new ArrayList<>(); + for (Object occurrence : toscaRequirement.getOccurrences()) { + if (occurrence.equals(AUTHORATIVE_UNBOUNDED_LITERAL)) { + occurrences.add(JPA_UNBOUNDED_VALUE); + } else { + occurrences.add((Double) occurrence); + } + } + } + + if (toscaRequirement.getProperties() != null) { + properties = new LinkedHashMap<>(); + for (Map.Entry toscaPropertyEntry : toscaRequirement.getProperties().entrySet()) { + String jpaProperty = new YamlJsonTranslator().toYaml(toscaPropertyEntry.getValue()); + properties.put(toscaPropertyEntry.getKey(), jpaProperty); + } + } + + } + + @Override + public List getKeys() { + return super.getKeys(); + } + + @Override + public void clean() { + super.clean(); + + capability = capability.trim(); + node = node.trim(); + relationship = relationship.trim(); + + properties = PfUtils.mapMap(properties, String::trim); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + if (properties != null) { + result = validateProperties(result); + } + + if (occurrences != null) { + result = validateOccurrences(result); + } + + return result; + } + + /** + * Validate the properties. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateProperties(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (String property : properties.values()) { + if (property == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), + PfValidationResult.ValidationResult.INVALID, "topology template property may not be null ")); + } + } + return result; + } + + /** + * Validate the occurrences. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateOccurrences(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (Double occurrence : occurrences) { + if (occurrence == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), + PfValidationResult.ValidationResult.INVALID, "requirement occurrence value may not be null ")); + } + if (occurrence < -1.0) { + result.addValidationMessage( + new PfValidationMessage(getKey(), this.getClass(), PfValidationResult.ValidationResult.INVALID, + "requirement occurrence value may not be negative")); + } + } + + return result; + } + + @Override + public int compareTo(final PfConcept otherConcept) { + if (otherConcept == null) { + return -1; + } + + if (this == otherConcept) { + return 0; + } + + if (getClass() != otherConcept.getClass()) { + return getClass().getName().compareTo(otherConcept.getClass().getName()); + } + + final JpaToscaRequirement other = (JpaToscaRequirement) otherConcept; + int result = super.compareTo(other); + if (result != 0) { + return result; + } + + result = capability.compareTo(other.capability); + if (result != 0) { + return result; + } + + result = node.compareTo(other.node); + if (result != 0) { + return result; + } + + result = relationship.compareTo(other.relationship); + if (result != 0) { + return result; + } + + result = PfUtils.compareCollections(occurrences, other.occurrences); + if (result != 0) { + return result; + } + + return PfUtils.compareMaps(properties, other.properties); + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java new file mode 100644 index 000000000..08dbb43de --- /dev/null +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java @@ -0,0 +1,116 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +import javax.persistence.Entity; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Table; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NonNull; +import lombok.ToString; +import org.onap.policy.models.base.PfAuthorative; +import org.onap.policy.models.base.PfConceptContainer; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaRequirement; +import org.onap.policy.models.tosca.utils.ToscaUtils; + +/** + * This class is a container for TOSCA requirements. + * + * @author Liam Fallon (liam.fallon@est.tech) + */ +@Entity +@Table(name = "ToscaRequirements") +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +@Data +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +public class JpaToscaRequirements extends PfConceptContainer + implements PfAuthorative>> { + private static final long serialVersionUID = -7526648702327776101L; + + public static final String DEFAULT_NAME = "ToscaRequirementsSimple"; + public static final String DEFAULT_VERSION = "1.0.0"; + + /** + * The Default Constructor creates a {@link JpaToscaRequirements} object with a null artifact key and creates an + * empty concept map. + */ + public JpaToscaRequirements() { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + } + + /** + * The Key Constructor creates a {@link JpaToscaRequirements} object with the given artifact key and creates an + * empty concept map. + * + * @param key the concept key + */ + public JpaToscaRequirements(final PfConceptKey key) { + super(key, new TreeMap<>()); + } + + /** + * This Constructor creates an concept container with all of its fields defined. + * + * @param key the concept container key + * @param conceptMap the concepts to be stored in the concept container + */ + public JpaToscaRequirements(final PfConceptKey key, final Map conceptMap) { + super(key, conceptMap); + } + + /** + * Copy constructor. + * + * @param copyConcept the concept to copy from + */ + public JpaToscaRequirements(final JpaToscaRequirements copyConcept) { + super(copyConcept); + } + + /** + * Authorative constructor. + * + * @param authorativeConceptMapList the authorative concept to copy from + */ + public JpaToscaRequirements(final List> authorativeConceptMapList) { + super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION)); + this.fromAuthorative(authorativeConceptMapList); + } + + @Override + public PfValidationResult validate(@NonNull final PfValidationResult resultIn) { + PfValidationResult result = super.validate(resultIn); + + for (JpaToscaRequirement requirement : this.getConceptMap().values()) { + ToscaUtils.getEntityTypeAncestors(this, requirement, result); + } + + return result; + } +} diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchema.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinition.java similarity index 89% rename from models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchema.java rename to models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinition.java index ef6aa7e92..6bd1b44cd 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchema.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinition.java @@ -53,8 +53,8 @@ import org.onap.policy.models.tosca.authorative.concepts.ToscaSchemaDefinition; @Data @EqualsAndHashCode(callSuper = false) @NoArgsConstructor -public class JpaToscaEntrySchema - implements PfAuthorative, Serializable, Comparable { +public class JpaToscaSchemaDefinition + implements PfAuthorative, Serializable, Comparable { private static final long serialVersionUID = 3645882081163287058L; @@ -68,14 +68,14 @@ public class JpaToscaEntrySchema private String description; @ElementCollection - private List constraints = new ArrayList<>(); + private List constraints; /** - * The full constructor creates a {@link JpaToscaEntrySchema} object with mandatory fields. + * The full constructor creates a {@link JpaToscaSchemaDefinition} object with mandatory fields. * * @param type the type of the entry schema */ - public JpaToscaEntrySchema(@NonNull final PfConceptKey type) { + public JpaToscaSchemaDefinition(@NonNull final PfConceptKey type) { this.type = type; } @@ -84,7 +84,7 @@ public class JpaToscaEntrySchema * * @param copyConcept the concept to copy from */ - public JpaToscaEntrySchema(@NonNull final JpaToscaEntrySchema copyConcept) { + public JpaToscaSchemaDefinition(@NonNull final JpaToscaSchemaDefinition copyConcept) { copyConcept.copyTo(this); } @@ -93,7 +93,7 @@ public class JpaToscaEntrySchema * * @param authorativeConcept the authorative concept to copy from */ - public JpaToscaEntrySchema(final ToscaSchemaDefinition authorativeConcept) { + public JpaToscaSchemaDefinition(final ToscaSchemaDefinition authorativeConcept) { this.fromAuthorative(authorativeConcept); } @@ -180,7 +180,7 @@ public class JpaToscaEntrySchema } @Override - public int compareTo(final JpaToscaEntrySchema other) { + public int compareTo(final JpaToscaSchemaDefinition other) { if (other == null) { return -1; } @@ -193,7 +193,7 @@ public class JpaToscaEntrySchema return result; } - return PfUtils.compareObjects(constraints, other.constraints); + return PfUtils.compareCollections(constraints, other.constraints); } /** @@ -202,10 +202,10 @@ public class JpaToscaEntrySchema * @param target the other schemaa * @return the copied concept */ - public JpaToscaEntrySchema copyTo(@NonNull final JpaToscaEntrySchema target) { - Assertions.instanceOf(target, JpaToscaEntrySchema.class); + public JpaToscaSchemaDefinition copyTo(@NonNull final JpaToscaSchemaDefinition target) { + Assertions.instanceOf(target, JpaToscaSchemaDefinition.class); - final JpaToscaEntrySchema copy = (target); + final JpaToscaSchemaDefinition copy = (target); copy.setType(new PfConceptKey(type)); copy.setDescription(description); diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java index f1a6a395f..791801616 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java @@ -49,8 +49,11 @@ import org.onap.policy.models.base.PfKey; import org.onap.policy.models.base.PfValidationMessage; import org.onap.policy.models.base.PfValidationResult; import org.onap.policy.models.base.PfValidationResult.ValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType; import org.onap.policy.models.tosca.authorative.concepts.ToscaDataType; +import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType; import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType; +import org.onap.policy.models.tosca.authorative.concepts.ToscaRelationshipType; import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate; /** @@ -88,6 +91,36 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType()); + List> capabilityTypeMapList = capabilityTypes.toAuthorative(); + for (Map capabilityTypeMap : capabilityTypeMapList) { + toscaServiceTemplate.getCapabilityTypes().putAll(capabilityTypeMap); + } + } + + if (relationshipTypes != null) { + toscaServiceTemplate.setRelationshipTypes(new LinkedHashMap<>()); + List> relationshipTypeMapList = relationshipTypes.toAuthorative(); + for (Map relationshipTypeMap : relationshipTypeMapList) { + toscaServiceTemplate.getRelationshipTypes().putAll(relationshipTypeMap); + } + } + + if (nodeTypes != null) { + toscaServiceTemplate.setNodeTypes(new LinkedHashMap<>()); + List> nodeTypeMapList = nodeTypes.toAuthorative(); + for (Map nodeTypeMap : nodeTypeMapList) { + toscaServiceTemplate.getNodeTypes().putAll(nodeTypeMap); + } + } + if (policyTypes != null) { toscaServiceTemplate.setPolicyTypes(new LinkedHashMap<>()); List> policyTypeMapList = policyTypes.toAuthorative(); @@ -213,6 +276,21 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType inputs; + + @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true) + @JoinColumns( + { + @JoinColumn(name = "nodeTemplatesName", referencedColumnName = "name"), + @JoinColumn(name = "nodeTemplatessVersion", referencedColumnName = "version") + } + ) + @SerializedName("data_types") + private JpaToscaNodeTemplates nodeTemplates; + @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true) @JoinColumns( { @@ -105,6 +128,9 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative super(copyConcept); this.key = new PfReferenceKey(copyConcept.key); this.description = copyConcept.description; + this.inputs = PfUtils.mapMap(copyConcept.inputs, JpaToscaParameter::new); + this.nodeTemplates = + (copyConcept.nodeTemplates != null ? new JpaToscaNodeTemplates(copyConcept.nodeTemplates) : null); this.policies = (copyConcept.policies != null ? new JpaToscaPolicies(copyConcept.policies) : null); } @@ -123,6 +149,24 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative toscaTopologyTemplate.setDescription(description); + if (inputs != null) { + Map inputMap = new LinkedHashMap<>(); + + for (Map.Entry entry : inputs.entrySet()) { + inputMap.put(entry.getKey(), entry.getValue().toAuthorative()); + } + + toscaTopologyTemplate.setInputs(inputMap); + } + + if (nodeTemplates != null) { + toscaTopologyTemplate.setNodeTemplates(new LinkedHashMap<>()); + List> nodeTemplateMapList = nodeTemplates.toAuthorative(); + for (Map nodeTemplateMap : nodeTemplateMapList) { + toscaTopologyTemplate.getNodeTemplates().putAll(nodeTemplateMap); + } + } + if (policies != null) { toscaTopologyTemplate.setPolicies(policies.toAuthorative()); } @@ -134,6 +178,20 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative public void fromAuthorative(ToscaTopologyTemplate toscaTopologyTemplate) { description = toscaTopologyTemplate.getDescription(); + if (toscaTopologyTemplate.getInputs() != null) { + inputs = new LinkedHashMap<>(); + for (Map.Entry toscaInputEntry : toscaTopologyTemplate.getInputs().entrySet()) { + JpaToscaParameter jpaInput = new JpaToscaParameter(toscaInputEntry.getValue()); + jpaInput.setKey(new PfReferenceKey(getKey(), toscaInputEntry.getKey())); + inputs.put(toscaInputEntry.getKey(), jpaInput); + } + } + + if (toscaTopologyTemplate.getNodeTemplates() != null) { + nodeTemplates = new JpaToscaNodeTemplates(); + nodeTemplates.fromAuthorative(Collections.singletonList(toscaTopologyTemplate.getNodeTemplates())); + } + if (toscaTopologyTemplate.getPolicies() != null) { policies = new JpaToscaPolicies(); policies.fromAuthorative(toscaTopologyTemplate.getPolicies()); @@ -144,6 +202,16 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative public List getKeys() { final List keyList = getKey().getKeys(); + if (inputs != null) { + for (JpaToscaParameter input : inputs.values()) { + keyList.addAll(input.getKeys()); + } + } + + if (nodeTemplates != null) { + keyList.addAll(nodeTemplates.getKeys()); + } + if (policies != null) { keyList.addAll(policies.getKeys()); } @@ -157,6 +225,16 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative description = (description != null ? description.trim() : null); + if (inputs != null) { + for (JpaToscaParameter input : inputs.values()) { + input.clean(); + } + } + + if (nodeTemplates != null) { + nodeTemplates.clean(); + } + if (policies != null) { policies.clean(); } @@ -178,6 +256,15 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative "property description may not be blank")); } + if (inputs != null) { + result = validateInputs(result); + } + + + if (nodeTemplates != null) { + result = nodeTemplates.validate(result); + } + if (policies != null) { result = policies.validate(result); } @@ -185,6 +272,26 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative return result; } + /** + * Validate the inputs. + * + * @param resultIn The result of validations up to now + * @return the validation result + */ + private PfValidationResult validateInputs(final PfValidationResult resultIn) { + PfValidationResult result = resultIn; + + for (JpaToscaParameter input : inputs.values()) { + if (input == null) { + result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID, + "topology template input may not be null ")); + } else { + result = input.validate(result); + } + } + return result; + } + @Override public int compareTo(final PfConcept otherConcept) { int result = compareToWithoutEntities(otherConcept); @@ -192,11 +299,23 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative return result; } - return ObjectUtils.compare(policies, ((JpaToscaTopologyTemplate) otherConcept).policies); + final JpaToscaTopologyTemplate other = (JpaToscaTopologyTemplate) otherConcept; + + result = PfUtils.compareObjects(inputs, other.inputs); + if (result != 0) { + return result; + } + + result = ObjectUtils.compare(nodeTemplates, other.nodeTemplates); + if (result != 0) { + return result; + } + + return ObjectUtils.compare(policies, other.policies); } /** - * Compare this topology template to another topology template, ignoring contained entitites. + * Compare this topology template to another topology template, ignoring contained entities. * * @param otherConcept the other topology template * @return the result of the comparison diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java index 417e83fe0..10a9d2f66 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java @@ -3,7 +3,7 @@ * ONAP Policy Model * ================================================================================ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. - * Modifications Copyright (C) 2019 Nordix Foundation. + * Modifications Copyright (C) 2019-2020 Nordix Foundation. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -137,7 +137,7 @@ public class JpaToscaTrigger extends PfConcept { this.eventType = copyConcept.eventType; this.schedule = (copyConcept.schedule != null ? new JpaToscaTimeInterval(copyConcept.schedule) : null); this.targetFilter = - (copyConcept.targetFilter != null ? new JpaToscaEventFilter(copyConcept.targetFilter) : null); + (copyConcept.targetFilter != null ? new JpaToscaEventFilter(copyConcept.targetFilter) : null); this.condition = copyConcept.condition; this.constraint = copyConcept.constraint; this.period = copyConcept.period; @@ -245,16 +245,16 @@ public class JpaToscaTrigger extends PfConcept { } final JpaToscaTrigger other = (JpaToscaTrigger) otherConcept; - if (!key.equals(other.key)) { - return key.compareTo(other.key); + int result = key.compareTo(other.key); + if (result != 0) { + return result; } return compareFields(other); } /** - * Compare the fields of this ToscaTrigger object with the fields of the other ToscaProperty - * object. + * Compare the fields of this ToscaTrigger object with the fields of the other ToscaProperty object. * * @param other the other ToscaTrigger object */ diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java index 5b6855d95..7bf4d29e8 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java @@ -125,9 +125,9 @@ public class ToscaServiceTemplateUtils { for (Entry> fragmentEntry : fragmentContainer .getConceptMap().entrySet()) { - JpaToscaEntityType containerEntry = + JpaToscaEntityType containerEntity = compositeContainer.getConceptMap().get(fragmentEntry.getKey()); - if (containerEntry != null && !containerEntry.equals(fragmentEntry.getValue())) { + if (containerEntity != null && containerEntity.compareTo(fragmentEntry.getValue()) != 0) { result.addValidationMessage(new PfValidationMessage(fragmentEntry.getKey(), ToscaServiceTemplateUtils.class, ValidationResult.INVALID, "entity in incoming fragment does not equal existing entity")); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java new file mode 100644 index 000000000..ee2fee86b --- /dev/null +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java @@ -0,0 +1,158 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.models.tosca.simple.concepts; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfValidationResult; +import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment; + +/** + * DAO test for JpaToscaCapabilityAssignment. + */ +public class JpaToscaCapabilityAssignmentTest { + + private static final String KEY_IS_NULL = "key is marked .*on.*ull but is null"; + + @Test + public void testPropertyPojo() { + assertNotNull(new JpaToscaCapabilityAssignment()); + assertNotNull(new JpaToscaCapabilityAssignment(new PfConceptKey())); + assertNotNull(new JpaToscaCapabilityAssignment(new JpaToscaCapabilityAssignment())); + assertNotNull(new JpaToscaCapabilityAssignment(new ToscaCapabilityAssignment())); + + assertThatThrownBy(() -> new JpaToscaCapabilityAssignment((PfConceptKey) null)).hasMessageMatching(KEY_IS_NULL); + assertThatThrownBy(() -> new JpaToscaCapabilityAssignment((JpaToscaCapabilityAssignment) null)) + .hasMessageMatching("copyConcept is marked .*on.*ull but is null"); + assertThatThrownBy(() -> new JpaToscaCapabilityAssignment((ToscaCapabilityAssignment) null)) + .hasMessageMatching("authorativeConcept is marked .*on.*ull but is null"); + + PfConceptKey caKey = new PfConceptKey("tParentKey", "0.0.1"); + + JpaToscaCapabilityAssignment caNull = new JpaToscaCapabilityAssignment(caKey); + caNull.setProperties(null); + caNull.setAttributes(null); + caNull.setOccurrences(null); + + assertEquals(caNull, new JpaToscaCapabilityAssignment(caNull)); + + JpaToscaCapabilityAssignment ca = new JpaToscaCapabilityAssignment(caKey); + + assertEquals(ca, new JpaToscaCapabilityAssignment(ca)); + assertEquals(caKey, ca.getKeys().get(0)); + + ca.clean(); + ca.validate(new PfValidationResult()); + assertThat(ca.getProperties()).isNullOrEmpty(); + assertThat(ca.getAttributes()).isNullOrEmpty(); + + ca.setProperties(null); + ca.setAttributes(null); + ca.setOccurrences(null); + ca.clean(); + ca.validate(new PfValidationResult()); + assertEquals(null, ca.getProperties()); + assertEquals(null, ca.getAttributes()); + + Map properties = new LinkedHashMap<>(); + properties.put("Key0", " Untrimmed Value "); + ca.setProperties(properties); + + Map attributes = new LinkedHashMap<>(); + attributes.put("Key0", " Untrimmed Value "); + ca.setAttributes(attributes); + + List occurrences = new ArrayList<>(); + occurrences.add(12345); + ca.setOccurrences(occurrences); + + ca.clean(); + ca.validate(new PfValidationResult()); + assertEquals("Untrimmed Value", ca.getProperties().get("Key0")); + assertEquals("Untrimmed Value", ca.getAttributes().get("Key0")); + + ca.getProperties().put("Key1", null); + ca.getAttributes().put("Key1", null); + ca.getOccurrences().add(null); + ca.getOccurrences().add(-12345); + PfValidationResult result = ca.validate(new PfValidationResult()); + assertThat(result.toString()).contains("capability assignment property Key1 value may not be null"); + assertThat(result.toString()).contains("capability assignment attribute Key1 value may not be null"); + assertThat(result.toString()).contains("capability assignment occurrence value may not be negative"); + } + + @Test + public void testCompareTo() { + assertEquals(-1, new JpaToscaCapabilityAssignment().compareTo(null)); + assertEquals(0, new JpaToscaCapabilityAssignment().compareTo(new JpaToscaCapabilityAssignment())); + + JpaToscaCapabilityAssignment ca = new JpaToscaCapabilityAssignment(); + assertEquals(0, ca.compareTo(ca)); + assertEquals(18, ca.compareTo(new PfConceptKey())); + + JpaToscaCapabilityAssignment ca2 = new JpaToscaCapabilityAssignment(); + ca2.getKey().setName("ca2"); + assertEquals(-21, ca.compareTo(ca2)); + + ca.getKey().setName("ca"); + ca2.getKey().setName("ca"); + + ca.setProperties(new LinkedHashMap<>()); + ca2.setProperties(new LinkedHashMap<>()); + ca.getProperties().put("Key0", "Value0"); + assertEquals(-1737938642, ca.compareTo(ca2)); + ca2.getProperties().put("Key0", "Value0"); + assertEquals(0, ca.compareTo(ca2)); + + ca.setAttributes(new LinkedHashMap<>()); + ca2.setAttributes(new LinkedHashMap<>()); + ca.getAttributes().put("Key0", "Value0"); + assertEquals(-1737938642, ca.compareTo(ca2)); + ca2.getAttributes().put("Key0", "Value0"); + assertEquals(0, ca.compareTo(ca2)); + + ca.setOccurrences(new ArrayList<>()); + ca2.setOccurrences(new ArrayList<>()); + ca.getOccurrences().add(12345); + assertEquals(12375, ca.compareTo(ca2)); + ca2.getOccurrences().add(12345); + assertEquals(0, ca.compareTo(ca2)); + } + + @Test + public void testAuthorative() { + ToscaCapabilityAssignment tca = + new JpaToscaCapabilityAssignment(new ToscaCapabilityAssignment()).toAuthorative(); + + JpaToscaCapabilityAssignment jtca = new JpaToscaCapabilityAssignment(tca); + ToscaCapabilityAssignment tca2 = jtca.toAuthorative(); + assertEquals(tca, tca2); + } +} diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java index e00e48f21..7168f488c 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java @@ -174,7 +174,7 @@ public class JpaToscaDataTypeTest { JpaToscaProperty prop3 = new JpaToscaProperty(new PfReferenceKey(dt0.getKey(), "prop4")); prop3.setType(new PfConceptKey("the.property.Type1", "0.0.1")); - prop3.setEntrySchema(new JpaToscaEntrySchema()); + prop3.setEntrySchema(new JpaToscaSchemaDefinition()); prop3.getEntrySchema().setType(new PfConceptKey("the.property.Type3", "0.0.1")); assertTrue(prop3.validate(new PfValidationResult()).isValid()); @@ -183,7 +183,7 @@ public class JpaToscaDataTypeTest { JpaToscaProperty prop4 = new JpaToscaProperty(new PfReferenceKey(dt0.getKey(), "prop4")); prop4.setType(new PfConceptKey("the.property.Type1", "0.0.1")); - prop4.setEntrySchema(new JpaToscaEntrySchema()); + prop4.setEntrySchema(new JpaToscaSchemaDefinition()); prop4.getEntrySchema().setType(new PfConceptKey("the.property.Type2", "0.0.1")); assertTrue(prop4.validate(new PfValidationResult()).isValid()); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java index 14a0b6a96..7f356224f 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java @@ -30,11 +30,13 @@ import static org.junit.Assert.assertTrue; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import org.junit.Test; import org.onap.policy.models.base.PfConceptKey; import org.onap.policy.models.base.PfKey; +import org.onap.policy.models.base.PfUtils; import org.onap.policy.models.base.PfValidationResult; import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy; @@ -60,8 +62,8 @@ public class JpaToscaPolicyTest { assertThatThrownBy(() -> { new JpaToscaPolicy(pol); }).hasMessage( - "PolicyType version not specified, the version of the PolicyType for this policy must be specified in the " - + "type_version field"); + "PolicyType version not specified, the version of the PolicyType for this policy must be specified in" + + " the type_version field"); assertThatThrownBy(() -> { new JpaToscaPolicy((PfConceptKey) null); @@ -182,4 +184,44 @@ public class JpaToscaPolicyTest { tp.fromAuthorative(pol1); assertEquals("2.2.3", tp.getType().getVersion()); } + + @Test + public void testPolicyProperties() { + + Map properties = new LinkedHashMap<>(); + + // @formatter:off + properties.put("byte", Byte.valueOf("2")); + properties.put("short", Short.valueOf("1234")); + properties.put("int", Integer.valueOf("12345678")); + properties.put("long", Long.valueOf("1234567890")); + properties.put("float", Float.valueOf("12345.678")); + properties.put("double", Double.valueOf("-12345.6789")); + properties.put("char", '%'); + properties.put("string", "hello"); + properties.put("boolean", false); + // @formatter:on + + ToscaPolicy tp = new ToscaPolicy(); + tp.setType("org.onap.Policy"); + tp.setTypeVersion("1.2.3"); + tp.setProperties(properties); + + JpaToscaPolicy jtp = new JpaToscaPolicy(tp); + assertEquals(0, PfUtils.compareCollections(tp.getProperties().keySet(), jtp.getProperties().keySet())); + + ToscaPolicy tpFromTo = jtp.toAuthorative(); + + // @formatter:off + assertEquals(2, tpFromTo.getProperties().get("byte")); + assertEquals(1234, tpFromTo.getProperties().get("short")); + assertEquals(12345678, tpFromTo.getProperties().get("int")); + assertEquals(1234567890, tpFromTo.getProperties().get("long")); + assertEquals(12345.678, tpFromTo.getProperties().get("float")); + assertEquals(-12345.6789, tpFromTo.getProperties().get("double")); + assertEquals("%", tpFromTo.getProperties().get("char")); + assertEquals("hello", tpFromTo.getProperties().get("string")); + assertEquals(false, tpFromTo.getProperties().get("boolean")); + // @formatter:on + } } diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java index 5a18902d0..43cacda19 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java @@ -221,7 +221,7 @@ public class JpaToscaPolicyTypeTest { JpaToscaProperty prop3 = new JpaToscaProperty(new PfReferenceKey(pt0.getKey(), "prop4")); prop3.setType(new PfConceptKey("the.property.Type1", "0.0.1")); - prop3.setEntrySchema(new JpaToscaEntrySchema()); + prop3.setEntrySchema(new JpaToscaSchemaDefinition()); prop3.getEntrySchema().setType(new PfConceptKey("the.property.Type3", "0.0.1")); assertTrue(prop3.validate(new PfValidationResult()).isValid()); @@ -230,7 +230,7 @@ public class JpaToscaPolicyTypeTest { JpaToscaProperty prop4 = new JpaToscaProperty(new PfReferenceKey(pt0.getKey(), "prop4")); prop4.setType(new PfConceptKey("the.property.Type1", "0.0.1")); - prop4.setEntrySchema(new JpaToscaEntrySchema()); + prop4.setEntrySchema(new JpaToscaSchemaDefinition()); prop4.getEntrySchema().setType(new PfConceptKey("the.property.Type2", "0.0.1")); assertTrue(prop4.validate(new PfValidationResult()).isValid()); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java index ac2f6030f..0fa0d3f14 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java @@ -91,7 +91,7 @@ public class JpaToscaPropertyTest { assertEquals(constraints, tp.getConstraints()); PfConceptKey typeKey = new PfConceptKey("type", VERSION_001); - JpaToscaEntrySchema tes = new JpaToscaEntrySchema(typeKey); + JpaToscaSchemaDefinition tes = new JpaToscaSchemaDefinition(typeKey); tp.setEntrySchema(tes); TreeMap metadata = new TreeMap<>(); @@ -134,6 +134,8 @@ public class JpaToscaPropertyTest { otherDt.setConstraints(constraints); assertNotEquals(0, tp.compareTo(otherDt)); otherDt.setEntrySchema(tes); + assertNotEquals(0, tp.compareTo(otherDt)); + otherDt.setMetadata(metadata); assertEquals(0, tp.compareTo(otherDt)); otherDt.setRequired(true); @@ -220,7 +222,7 @@ public class JpaToscaPropertyTest { tp.setConstraints(constraints); PfConceptKey typeKey = new PfConceptKey("type", VERSION_001); - JpaToscaEntrySchema tes = new JpaToscaEntrySchema(typeKey); + JpaToscaSchemaDefinition tes = new JpaToscaSchemaDefinition(typeKey); tp.setEntrySchema(tes); TreeMap metadata = new TreeMap<>(); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchemaTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinitionTest.java similarity index 81% rename from models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchemaTest.java rename to models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinitionTest.java index 83d6aad97..e7163f756 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchemaTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinitionTest.java @@ -39,23 +39,23 @@ import org.onap.policy.models.base.PfValidationResult; * * @author Liam Fallon (liam.fallon@est.tech) */ -public class JpaToscaEntrySchemaTest { +public class JpaToscaSchemaDefinitionTest { private static final String A_DESCRIPTION = "A Description"; @Test public void testEntrySchemaPojo() { - assertNotNull(new JpaToscaEntrySchema(new PfConceptKey())); - assertNotNull(new JpaToscaEntrySchema(new JpaToscaEntrySchema(new PfConceptKey()))); + assertNotNull(new JpaToscaSchemaDefinition(new PfConceptKey())); + assertNotNull(new JpaToscaSchemaDefinition(new JpaToscaSchemaDefinition(new PfConceptKey()))); - assertThatThrownBy(() -> new JpaToscaEntrySchema((PfConceptKey) null)) + assertThatThrownBy(() -> new JpaToscaSchemaDefinition((PfConceptKey) null)) .hasMessageMatching("type is marked .*on.*ull but is null"); - assertThatThrownBy(() -> new JpaToscaEntrySchema((JpaToscaEntrySchema) null)) + assertThatThrownBy(() -> new JpaToscaSchemaDefinition((JpaToscaSchemaDefinition) null)) .hasMessageMatching("copyConcept is marked .*on.*ull but is null"); PfConceptKey typeKey = new PfConceptKey("type", "0.0.1"); - JpaToscaEntrySchema tes = new JpaToscaEntrySchema(typeKey); + JpaToscaSchemaDefinition tes = new JpaToscaSchemaDefinition(typeKey); tes.setDescription(A_DESCRIPTION); assertEquals(A_DESCRIPTION, tes.getDescription()); @@ -66,18 +66,18 @@ public class JpaToscaEntrySchemaTest { tes.setConstraints(constraints); assertEquals(constraints, tes.getConstraints()); - JpaToscaEntrySchema tdtClone0 = new JpaToscaEntrySchema(tes); + JpaToscaSchemaDefinition tdtClone0 = new JpaToscaSchemaDefinition(tes); assertEquals(tes, tdtClone0); assertEquals(0, tes.compareTo(tdtClone0)); - JpaToscaEntrySchema tdtClone1 = new JpaToscaEntrySchema(tes); + JpaToscaSchemaDefinition tdtClone1 = new JpaToscaSchemaDefinition(tes); assertEquals(tes, tdtClone1); assertEquals(0, tes.compareTo(tdtClone1)); assertEquals(-1, tes.compareTo(null)); assertEquals(0, tes.compareTo(tes)); - JpaToscaEntrySchema otherEs = new JpaToscaEntrySchema(typeKey); + JpaToscaSchemaDefinition otherEs = new JpaToscaSchemaDefinition(typeKey); assertNotEquals(0, tes.compareTo(otherEs)); otherEs.setType(typeKey); @@ -90,13 +90,13 @@ public class JpaToscaEntrySchemaTest { assertThatThrownBy(() -> tes.copyTo(null)).hasMessageMatching("target is marked .*on.*ull but is null"); assertEquals(1, tes.getKeys().size()); - assertEquals(1, new JpaToscaEntrySchema(typeKey).getKeys().size()); + assertEquals(1, new JpaToscaSchemaDefinition(typeKey).getKeys().size()); - new JpaToscaEntrySchema(typeKey).clean(); + new JpaToscaSchemaDefinition(typeKey).clean(); tes.clean(); assertEquals(tdtClone0, tes); - assertTrue(new JpaToscaEntrySchema(typeKey).validate(new PfValidationResult()).isValid()); + assertTrue(new JpaToscaSchemaDefinition(typeKey).validate(new PfValidationResult()).isValid()); assertTrue(tes.validate(new PfValidationResult()).isValid()); tes.setType(PfConceptKey.getNullKey()); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java index 65d832b98..bb0d2dcb5 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java @@ -29,6 +29,7 @@ import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; +import java.util.LinkedHashMap; import java.util.Map; import java.util.TreeMap; import org.junit.Test; @@ -154,6 +155,8 @@ public class JpaToscaServiceTemplateTest { JpaToscaDataType dt0 = new JpaToscaDataType(new PfConceptKey("dt0:0.0.1")); JpaToscaProperty prop0 = new JpaToscaProperty(new PfReferenceKey(pt0.getKey(), "prop0")); prop0.setType(dt0.getKey()); + + pt0.setProperties(new LinkedHashMap<>()); pt0.getProperties().put(prop0.getKey().getLocalName(), prop0); result = tst.validate(new PfValidationResult()); assertFalse(result.isOk()); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java index 1e18f12d4..3c363b364 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java @@ -26,6 +26,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; +import java.util.LinkedHashMap; import java.util.Properties; import org.eclipse.persistence.config.PersistenceUnitProperties; import org.junit.After; @@ -119,7 +120,7 @@ public class SimpleToscaProviderTest { serviceTemplate.getDataTypes().getConceptMap().put(dataType0Key, dataType0); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate); assertEquals(1, createdServiceTemplate.getDataTypes().getConceptMap().size()); assertEquals(dataType0, createdServiceTemplate.getDataTypes().get(dataType0Key)); @@ -128,19 +129,19 @@ public class SimpleToscaProviderTest { dataType0.setDescription("Updated Description"); JpaToscaServiceTemplate updatedServiceTemplate = - new SimpleToscaProvider().updateDataTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().updateDataTypes(pfDao, serviceTemplate); assertEquals(dataType0, updatedServiceTemplate.getDataTypes().get(dataType0Key)); assertEquals("Updated Description", updatedServiceTemplate.getDataTypes().get(dataType0Key).getDescription()); JpaToscaServiceTemplate gotServiceTemplate = - new SimpleToscaProvider().getDataTypes(pfDao, dataType0Key.getName(), dataType0Key.getVersion()); + new SimpleToscaProvider().getDataTypes(pfDao, dataType0Key.getName(), dataType0Key.getVersion()); assertEquals(dataType0, gotServiceTemplate.getDataTypes().get(dataType0Key)); assertEquals("Updated Description", gotServiceTemplate.getDataTypes().get(dataType0Key).getDescription()); assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, new PfConceptKey("IDontExist:0.0.1"))) - .hasMessage("data type IDontExist:0.0.1 not found"); + .hasMessage("data type IDontExist:0.0.1 not found"); JpaToscaServiceTemplate deletedServiceTemplate = new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key); @@ -161,7 +162,7 @@ public class SimpleToscaProviderTest { assertEquals("Updated Description", deletedServiceTemplate.getDataTypes().get(dataType0Key).getDescription()); assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key)) - .hasMessage("no data types found"); + .hasMessage("no data types found"); // Create the data type again new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate); @@ -169,12 +170,13 @@ public class SimpleToscaProviderTest { JpaToscaPolicyType pt0v2 = new JpaToscaPolicyType(new PfConceptKey("pt0:0.0.2")); JpaToscaProperty prop0 = new JpaToscaProperty(new PfReferenceKey(pt0v2.getKey(), "prop0")); prop0.setType(dataType0Key); + pt0v2.setProperties(new LinkedHashMap<>()); pt0v2.getProperties().put(prop0.getKey().getLocalName(), prop0); updatedServiceTemplate.getPolicyTypes().getConceptMap().put(pt0v2.getKey(), pt0v2); new SimpleToscaProvider().createPolicyTypes(pfDao, updatedServiceTemplate); assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key)) - .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2"); + .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2"); JpaToscaDataType dataType0v2 = new JpaToscaDataType(new PfConceptKey("DataType0:0.0.2")); updatedServiceTemplate.getDataTypes().getConceptMap().put(dataType0v2.getKey(), dataType0v2); @@ -186,17 +188,18 @@ public class SimpleToscaProviderTest { assertNull(deletedServiceTemplate.getDataTypes().get(dataType0v2.getKey()).getDescription()); assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key)) - .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2"); + .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2"); JpaToscaDataType dataType1 = new JpaToscaDataType(new PfConceptKey("DataType1:0.0.3")); JpaToscaProperty prop1 = new JpaToscaProperty(new PfReferenceKey(dataType1.getKey(), "prop1")); prop1.setType(dataType0v2.getKey()); + dataType1.setProperties(new LinkedHashMap<>()); dataType1.getProperties().put(prop1.getKey().getLocalName(), prop1); updatedServiceTemplate.getDataTypes().getConceptMap().put(dataType1.getKey(), dataType1); new SimpleToscaProvider().createDataTypes(pfDao, updatedServiceTemplate); assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0v2.getKey())) - .hasMessage("data type DataType0:0.0.2 is in use, it is referenced in data type DataType1:0.0.3"); + .hasMessage("data type DataType0:0.0.2 is in use, it is referenced in data type DataType1:0.0.3"); } @Test @@ -216,7 +219,7 @@ public class SimpleToscaProviderTest { serviceTemplate.getPolicyTypes().getConceptMap().put(policyType0Key, policyType0); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); assertEquals(1, createdServiceTemplate.getPolicyTypes().getConceptMap().size()); assertEquals(policyType0, createdServiceTemplate.getPolicyTypes().get(policyType0Key)); @@ -225,14 +228,14 @@ public class SimpleToscaProviderTest { policyType0.setDescription("Updated Description"); JpaToscaServiceTemplate updatedServiceTemplate = - new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate); assertEquals(policyType0, updatedServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals("Updated Description", - updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); + updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); JpaToscaServiceTemplate gotServiceTemplate = - new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion()); + new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion()); assertEquals(policyType0, gotServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals("Updated Description", gotServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); @@ -247,7 +250,7 @@ public class SimpleToscaProviderTest { new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key)) - .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2"); + .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2"); serviceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate()); serviceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies()); @@ -262,10 +265,10 @@ public class SimpleToscaProviderTest { new SimpleToscaProvider().createPolicies(pfDao, serviceTemplate); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key)) - .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2"); + .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2"); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, pt1.getKey())) - .hasMessage("policy type pt1:0.0.2 is in use, it is referenced in policy p1:0.0.1"); + .hasMessage("policy type pt1:0.0.2 is in use, it is referenced in policy p1:0.0.1"); new SimpleToscaProvider().deletePolicy(pfDao, p1.getKey()); @@ -274,17 +277,17 @@ public class SimpleToscaProviderTest { new SimpleToscaProvider().deletePolicy(pfDao, p0.getKey()); JpaToscaServiceTemplate deletedServiceTemplate = - new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key); + new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key); assertEquals(policyType0, deletedServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals("Updated Description", - deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); + deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key)) - .hasMessage("no policy types found"); + .hasMessage("no policy types found"); JpaToscaServiceTemplate newServiceTemplate = - new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); assertEquals(serviceTemplate, newServiceTemplate); } @@ -299,7 +302,7 @@ public class SimpleToscaProviderTest { serviceTemplate.getPolicyTypes().getConceptMap().put(policyType0Key, policyType0); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate); assertEquals(policyType0, createdServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals(null, createdServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); @@ -307,33 +310,33 @@ public class SimpleToscaProviderTest { policyType0.setDescription("Updated Description"); JpaToscaServiceTemplate updatedServiceTemplate = - new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate); assertEquals(policyType0, updatedServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals("Updated Description", - updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); + updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); JpaToscaServiceTemplate gotServiceTemplate = - new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion()); + new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion()); assertEquals(policyType0, gotServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals("Updated Description", gotServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); JpaToscaServiceTemplate deletedServiceTemplate = - new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key); + new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key); assertEquals(policyType0, deletedServiceTemplate.getPolicyTypes().get(policyType0Key)); assertEquals("Updated Description", - deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); + deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription()); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key)) - .hasMessage("no policy types found"); + .hasMessage("no policy types found"); } @Test public void testPoliciesGet() throws Exception { ToscaServiceTemplate toscaServiceTemplate = - standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); + standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); createPolicyTypes(); @@ -342,18 +345,18 @@ public class SimpleToscaProviderTest { assertNotNull(originalServiceTemplate); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); + new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies(), - createdServiceTemplate.getTopologyTemplate().getPolicies()); + createdServiceTemplate.getTopologyTemplate().getPolicies()); PfConceptKey policyKey = new PfConceptKey("onap.restart.tca:1.0.0"); JpaToscaServiceTemplate gotServiceTemplate = - new SimpleToscaProvider().getPolicies(pfDao, policyKey.getName(), policyKey.getVersion()); + new SimpleToscaProvider().getPolicies(pfDao, policyKey.getName(), policyKey.getVersion()); - assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey), - gotServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey)); + assertEquals(0, originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey) + .compareTo(gotServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey))); JpaToscaServiceTemplate deletedServiceTemplate = new SimpleToscaProvider().deletePolicy(pfDao, policyKey); assertEquals(1, deletedServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().size()); @@ -362,7 +365,7 @@ public class SimpleToscaProviderTest { @Test public void testPolicyCreate() throws Exception { ToscaServiceTemplate toscaServiceTemplate = - standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); + standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); createPolicyTypes(); @@ -371,21 +374,21 @@ public class SimpleToscaProviderTest { assertNotNull(originalServiceTemplate); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); + new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies(), - createdServiceTemplate.getTopologyTemplate().getPolicies()); + createdServiceTemplate.getTopologyTemplate().getPolicies()); } @Test public void testPolicyCreateTypeAndVersion() throws Exception { ToscaServiceTemplate toscaServiceTemplate = - standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); + standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); createPolicyTypes(); ToscaPolicy toscaPolicy = - toscaServiceTemplate.getToscaTopologyTemplate().getPoliciesAsMap().values().iterator().next(); + toscaServiceTemplate.getToscaTopologyTemplate().getPoliciesAsMap().values().iterator().next(); JpaToscaServiceTemplate originalServiceTemplate = new JpaToscaServiceTemplate(); @@ -397,13 +400,13 @@ public class SimpleToscaProviderTest { assertThatThrownBy(() -> { originalServiceTemplate.fromAuthorative(toscaServiceTemplate); }).hasMessage("PolicyType type not specified, the type of the PolicyType for this policy must be " - + "specified in the type field"); + + "specified in the type field"); toscaPolicy.setType("IDontExist"); assertThatThrownBy(() -> { originalServiceTemplate.fromAuthorative(toscaServiceTemplate); }).hasMessage("PolicyType version not specified, the version of the PolicyType for this policy must be " - + "specified in the type_version field"); + + "specified in the type_version field"); toscaPolicy.setTypeVersion("hello"); assertThatThrownBy(() -> { @@ -425,22 +428,22 @@ public class SimpleToscaProviderTest { assertThatThrownBy(() -> { originalServiceTemplate.fromAuthorative(toscaServiceTemplate); }).hasMessage("PolicyType type not specified, the type of the PolicyType for this policy must be " - + "specified in the type field"); + + "specified in the type field"); toscaPolicy.setType(originalPolicyType); toscaPolicy.setTypeVersion(originalPolicyTypeVersion); originalServiceTemplate.fromAuthorative(toscaServiceTemplate); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); + new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies(), - createdServiceTemplate.getTopologyTemplate().getPolicies()); + createdServiceTemplate.getTopologyTemplate().getPolicies()); } @Test public void testPolicyUpdate() throws Exception { ToscaServiceTemplate toscaServiceTemplate = - standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); + standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); createPolicyTypes(); @@ -449,7 +452,7 @@ public class SimpleToscaProviderTest { assertNotNull(originalServiceTemplate); JpaToscaServiceTemplate updatedServiceTemplate = - new SimpleToscaProvider().updatePolicies(pfDao, originalServiceTemplate); + new SimpleToscaProvider().updatePolicies(pfDao, originalServiceTemplate); assertEquals(originalServiceTemplate, updatedServiceTemplate); } @@ -457,7 +460,7 @@ public class SimpleToscaProviderTest { @Test public void testPoliciesDelete() throws Exception { ToscaServiceTemplate toscaServiceTemplate = - standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); + standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class); createPolicyTypes(); @@ -466,26 +469,26 @@ public class SimpleToscaProviderTest { assertNotNull(originalServiceTemplate); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); + new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); assertEquals(originalServiceTemplate.getTopologyTemplate(), createdServiceTemplate.getTopologyTemplate()); PfConceptKey policyKey = new PfConceptKey("onap.restart.tca:1.0.0"); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicy(pfDao, new PfConceptKey("IDontExist:0.0.1"))) - .hasMessage("policy IDontExist:0.0.1 not found"); + .hasMessage("policy IDontExist:0.0.1 not found"); JpaToscaServiceTemplate deletedServiceTemplate = new SimpleToscaProvider().deletePolicy(pfDao, policyKey); - assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey), - deletedServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey)); + assertEquals(0, originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey) + .compareTo(deletedServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey))); assertThatThrownBy(() -> { new SimpleToscaProvider().getPolicies(pfDao, policyKey.getName(), policyKey.getVersion()); }).hasMessage("policies for onap.restart.tca:1.0.0 do not exist"); assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicy(pfDao, policyKey)) - .hasMessage("no policies found"); + .hasMessage("no policies found"); new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate); } @@ -495,21 +498,21 @@ public class SimpleToscaProviderTest { JpaToscaServiceTemplate testServiceTemplate = new JpaToscaServiceTemplate(); assertThatThrownBy(() -> new SimpleToscaProvider().createPolicies(pfDao, testServiceTemplate)) - .hasMessage("topology template not specified on service template"); + .hasMessage("topology template not specified on service template"); testServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate()); assertThatThrownBy(() -> new SimpleToscaProvider().createPolicies(pfDao, testServiceTemplate)) - .hasMessage("no policies specified on topology template of service template"); + .hasMessage("no policies specified on topology template of service template"); testServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies()); assertThatThrownBy(() -> new SimpleToscaProvider().createPolicies(pfDao, testServiceTemplate)) - .hasMessage("list of policies specified on topology template of service template is empty"); + .hasMessage("list of policies specified on topology template of service template is empty"); } @Test public void testGetServiceTemplate() throws PfModelException { assertThatThrownBy(() -> new SimpleToscaProvider().getServiceTemplate(pfDao)) - .hasMessage("service template not found in database"); + .hasMessage("service template not found in database"); } @Test @@ -520,8 +523,8 @@ public class SimpleToscaProviderTest { serviceTemplateFragment.getPolicyTypes().getConceptMap().put(badPt.getKey(), badPt); assertThatThrownBy(() -> new SimpleToscaProvider().appendToServiceTemplate(pfDao, serviceTemplateFragment)) - .hasMessageContaining( - "key on concept entry PfConceptKey(name=NULL, version=0.0.0) may not be the null key"); + .hasMessageContaining( + "key on concept entry PfConceptKey(name=NULL, version=0.0.0) may not be the null key"); } @Test @@ -609,7 +612,7 @@ public class SimpleToscaProviderTest { }).hasMessageMatching("policy types for hello:0.0.1 do not exist"); JpaToscaServiceTemplate gotSt = - new SimpleToscaProvider().getPolicyTypes(pfDao, pt01.getName(), pt01.getVersion()); + new SimpleToscaProvider().getPolicyTypes(pfDao, pt01.getName(), pt01.getVersion()); assertEquals(pt01, gotSt.getPolicyTypes().get(pt01.getKey())); assertEquals(pt01, gotSt.getPolicyTypes().get(pt01.getName())); @@ -674,10 +677,10 @@ public class SimpleToscaProviderTest { JpaToscaServiceTemplate gotSt = new SimpleToscaProvider().getPolicies(pfDao, p01.getName(), p01.getVersion()); - assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getKey())); - assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getName())); - assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), null)); - assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), p01.getVersion())); + assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getKey()))); + assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getName()))); + assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), null))); + assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), p01.getVersion()))); assertEquals(1, gotSt.getTopologyTemplate().getPolicies().getAll(null).size()); assertEquals(1, gotSt.getTopologyTemplate().getPolicies().getAll(null, null).size()); assertEquals(1, gotSt.getTopologyTemplate().getPolicies().getAll(p01.getName(), null).size()); @@ -859,7 +862,7 @@ public class SimpleToscaProviderTest { serviceTemplate.getDataTypes().getConceptMap().put(dataType0Key, dataType0); JpaToscaServiceTemplate createdServiceTemplate = - new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate); + new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate); assertEquals(1, createdServiceTemplate.getDataTypes().getConceptMap().size()); assertEquals(dataType0, createdServiceTemplate.getDataTypes().get(dataType0Key)); @@ -878,12 +881,12 @@ public class SimpleToscaProviderTest { } private void createPolicyTypes() throws CoderException, PfModelException { - Object yamlObject = new Yaml() - .load(ResourceUtils.getResourceAsString("policytypes/onap.policies.monitoring.tcagen2.yaml")); + Object yamlObject = + new Yaml().load(ResourceUtils.getResourceAsString("policytypes/onap.policies.monitoring.tcagen2.yaml")); String yamlAsJsonString = new StandardCoder().encode(yamlObject); ToscaServiceTemplate toscaServiceTemplatePolicyType = - standardCoder.decode(yamlAsJsonString, ToscaServiceTemplate.class); + standardCoder.decode(yamlAsJsonString, ToscaServiceTemplate.class); assertNotNull(toscaServiceTemplatePolicyType); new AuthorativeToscaProvider().createPolicyTypes(pfDao, toscaServiceTemplatePolicyType); diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java index f74fad4b4..ba486035c 100644 --- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java +++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java @@ -25,6 +25,7 @@ import static org.junit.Assert.assertTrue; import java.util.List; import java.util.Map; +import org.apache.commons.collections4.MapUtils; import org.junit.Before; import org.junit.Test; import org.onap.policy.common.utils.coder.CoderException; @@ -194,7 +195,7 @@ public class OptimizationPolicyTypeSerializationTest { String testnm = testName + " identity"; assertNotNull(testnm, prop); - assertEquals(testnm + " metadata", 0, prop.getMetadata().size()); + assertEquals(testnm + " metadata", true, MapUtils.isEmpty(prop.getMetadata())); } private void validateMatchable(String testName, Map metadata) { diff --git a/models-tosca/src/test/resources/META-INF/persistence.xml b/models-tosca/src/test/resources/META-INF/persistence.xml index de27dd9bc..d6ebf4eb5 100644 --- a/models-tosca/src/test/resources/META-INF/persistence.xml +++ b/models-tosca/src/test/resources/META-INF/persistence.xml @@ -23,19 +23,32 @@ org.eclipse.persistence.jpa.PersistenceProvider + org.onap.policy.models.base.PfConceptKey org.onap.policy.models.dao.converters.CDataConditioner org.onap.policy.models.dao.converters.Uuid2String - org.onap.policy.models.base.PfConceptKey + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignment + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignments + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityType + org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityTypes org.onap.policy.models.tosca.simple.concepts.JpaToscaDataType org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplates + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeType + org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTypes + org.onap.policy.models.tosca.simple.concepts.JpaToscaParameter org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicy org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyType org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes - org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate + org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty + org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipType + org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipTypes + org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirement + org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirements org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate + org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate org.onap.policy.models.tosca.simple.concepts.JpaToscaTrigger - org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty -- 2.16.6