+++ /dev/null
-/*\r
- * Copyright © 2017-2018 AT&T Intellectual Property.\r
- * Modifications Copyright © 2018 IBM.\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-package org.onap.ccsdk.apps.controllerblueprints.service.validator;\r
-\r
-import com.fasterxml.jackson.databind.JsonNode;\r
-import org.apache.commons.lang3.StringUtils;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactType;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.data.CapabilityDefinition;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType;\r
-import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils;\r
-import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-\r
-/**\r
- * ModelTypeValidation.java Purpose: Provide Validation Service for Model Type ModelTypeValidation\r
- *\r
- * @author Brinda Santh\r
- * @version 1.0\r
- */\r
-\r
-public class ModelTypeValidator {\r
-\r
- private ModelTypeValidator() {\r
-\r
- }\r
-\r
- private static List<String> getValidModelDefinitionType() {\r
- List<String> validTypes = new ArrayList<>();\r
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE);\r
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE);\r
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE);\r
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE);\r
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE);\r
- return validTypes;\r
- }\r
-\r
- /**\r
- * This is a validateModelTypeDefinition\r
- * \r
- * @param definitionType definitionType\r
- * @param definitionContent definitionContent\r
- * @return boolean\r
- * @throws BluePrintException BluePrintException\r
- */\r
- public static boolean validateModelTypeDefinition(String definitionType, JsonNode definitionContent)\r
- throws BluePrintException {\r
- if (definitionContent != null) {\r
- if (BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE.equalsIgnoreCase(definitionType)) {\r
- DataType dataType = JacksonUtils.readValue(definitionContent, DataType.class);\r
- if (dataType == null) {\r
- throw new BluePrintException(\r
- "Model type definition is not DataType valid content " + definitionContent);\r
- }\r
- } else if (BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE.equalsIgnoreCase(definitionType)) {\r
- NodeType nodeType = JacksonUtils.readValue(definitionContent, NodeType.class);\r
- if (nodeType == null) {\r
- throw new BluePrintException(\r
- "Model type definition is not NodeType valid content " + definitionContent);\r
- }\r
- } else if (BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE.equalsIgnoreCase(definitionType)) {\r
- ArtifactType artifactType = JacksonUtils.readValue(definitionContent, ArtifactType.class);\r
- if (artifactType == null) {\r
- throw new BluePrintException(\r
- "Model type definition is not ArtifactType valid content " + definitionContent);\r
- }\r
- }else if (BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE.equalsIgnoreCase(definitionType)) {\r
- CapabilityDefinition capabilityDefinition =\r
- JacksonUtils.readValue(definitionContent, CapabilityDefinition.class);\r
- if (capabilityDefinition == null) {\r
- throw new BluePrintException(\r
- "Model type definition is not CapabilityDefinition valid content " + definitionContent);\r
- }\r
- }\r
-\r
- }\r
- return true;\r
- }\r
-\r
- /**\r
- * This is a validateModelType method\r
- * \r
- * @param modelType modelType\r
- * @return boolean\r
- * @throws BluePrintException BluePrintException\r
- */\r
- public static boolean validateModelType(ModelType modelType) throws BluePrintException {\r
- if (modelType != null) {\r
-\r
- if (StringUtils.isBlank(modelType.getModelName())) {\r
- throw new BluePrintException("Model Name Information is missing.");\r
- }\r
-\r
- if (StringUtils.isBlank(modelType.getDefinitionType())) {\r
- throw new BluePrintException("Model Root Type Information is missing.");\r
- }\r
- if (StringUtils.isBlank(modelType.getDerivedFrom())) {\r
- throw new BluePrintException("Model Type Information is missing.");\r
- }\r
-\r
- if (modelType.getDefinition() == null) {\r
- throw new BluePrintException("Model Definition Information is missing.");\r
- }\r
- if (StringUtils.isBlank(modelType.getDescription())) {\r
- throw new BluePrintException("Model Description Information is missing.");\r
- }\r
-\r
- if (StringUtils.isBlank(modelType.getVersion())) {\r
- throw new BluePrintException("Model Version Information is missing.");\r
- }\r
-\r
- if (StringUtils.isBlank(modelType.getUpdatedBy())) {\r
- throw new BluePrintException("Model Updated By Information is missing.");\r
- }\r
-\r
- List<String> validRootTypes = getValidModelDefinitionType();\r
- if (!validRootTypes.contains(modelType.getDefinitionType())) {\r
- throw new BluePrintException("Not Valid Model Root Type(" + modelType.getDefinitionType()\r
- + "), It should be " + validRootTypes);\r
- }\r
-\r
- validateModelTypeDefinition(modelType.getDefinitionType(), modelType.getDefinition());\r
-\r
- } else {\r
- throw new BluePrintException("Model Type Information is missing.");\r
- }\r
-\r
- return true;\r
-\r
- }\r
-\r
-}\r
package org.onap.ccsdk.apps.controllerblueprints.service.load
import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.apps.controllerblueprints.core.config.BluePrintLoadConfiguration
import org.springframework.boot.context.event.ApplicationReadyEvent
import org.springframework.context.event.EventListener
if (bluePrintLoadConfiguration.loadModelType) {
val paths = bluePrintLoadConfiguration.loadModeTypePaths?.split(",")
paths?.let {
- modelTypeLoadService.loadPathsModelType(paths)
+ runBlocking {
+ modelTypeLoadService.loadPathsModelType(paths)
+ }
}
}
}
import org.apache.commons.io.FilenameUtils
import org.apache.commons.lang3.text.StrBuilder
import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactType
-import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType
-import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.data.*
import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
import org.onap.ccsdk.apps.controllerblueprints.service.handler.ModelTypeHandler
private val log = EELFManager.getInstance().getLogger(ModelTypeLoadService::class.java)
private val updateBySystem = "System"
- open fun loadPathsModelType(modelTypePaths: List<String>) {
- modelTypePaths.forEach { loadPathModelType(it) }
+ open suspend fun loadPathsModelType(modelTypePaths: List<String>) {
+ modelTypePaths.forEach { runBlocking { loadPathModelType(it) } }
}
- open fun loadPathModelType(modelTypePath: String) = runBlocking {
+ /**
+ * Load the Model Type file content from the defined path, Load of sequencing should be maintained.
+ */
+ open suspend fun loadPathModelType(modelTypePath: String) = runBlocking {
log.info(" *************************** loadModelType **********************")
try {
val errorBuilder = StrBuilder()
val deferredResults = mutableListOf<Deferred<Unit>>()
- for (file in dataTypeFiles) deferredResults += async { loadDataType(file, errorBuilder) }
+ for (file in dataTypeFiles) deferredResults += async {
+ loadModelType(file, DataType::class.java, errorBuilder)
+ }
deferredResults.awaitAll()
}
coroutineScope {
- val artifactTypefiles = File("$modelTypePath/artifact_type").listFiles()
+ val artifactTypeFiles = File("$modelTypePath/artifact_type").listFiles()
val deferredResults = mutableListOf<Deferred<Unit>>()
- for (file in artifactTypefiles) deferredResults += async { loadArtifactType(file, errorBuilder) }
+ for (file in artifactTypeFiles) deferredResults += async {
+ loadModelType(file,
+ ArtifactType::class.java, errorBuilder)
+ }
+
+ deferredResults.awaitAll()
+ }
+
+ coroutineScope {
+ val relationshipTypeFiles = File("$modelTypePath/relationship_type").listFiles()
+
+ val deferredResults = mutableListOf<Deferred<Unit>>()
+
+ for (file in relationshipTypeFiles) deferredResults += async {
+ loadModelType(file,
+ RelationshipType::class.java, errorBuilder)
+ }
deferredResults.awaitAll()
}
val deferredResults = mutableListOf<Deferred<Unit>>()
- for (file in nodeTypeFiles) deferredResults += async { loadNodeType(file, errorBuilder) }
+ for (file in nodeTypeFiles) deferredResults += async {
+ loadModelType(file,
+ NodeType::class.java, errorBuilder)
+ }
deferredResults.awaitAll()
}
}
}
- private fun loadDataType(file: File, errorBuilder: StrBuilder) {
- try {
- log.trace("Loading DataType(${file.name}")
- val dataKey = FilenameUtils.getBaseName(file.name)
- val definitionContent = file.readText(Charset.defaultCharset())
- val dataType = JacksonUtils.readValue(definitionContent, DataType::class.java)
- checkNotNull(dataType) { "failed to get data type from file : ${file.name}" }
-
- val modelType = ModelType()
- modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
- modelType.derivedFrom = dataType.derivedFrom
- modelType.description = dataType.description
- modelType.definition = JacksonUtils.jsonNode(definitionContent)
- modelType.modelName = dataKey
- modelType.version = dataType.version
- modelType.updatedBy = updateBySystem
- modelType.tags = (dataKey + "," + dataType.derivedFrom + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
- modelTypeHandler.saveModel(modelType)
- log.trace("DataType(${file.name}) loaded successfully ")
- } catch (e: Exception) {
- errorBuilder.appendln("Couldn't load DataType(${file.name}: ${e.message}")
- }
- }
-
- private fun loadArtifactType(file: File, errorBuilder: StrBuilder) {
+ private inline fun <reified T> loadModelType(file: File, classType: Class<T>, errorBuilder: StrBuilder) {
try {
- log.trace("Loading ArtifactType(${file.name}")
+ log.trace("Loading ${classType.name} (${file.name})")
val dataKey = FilenameUtils.getBaseName(file.name)
val definitionContent = file.readText(Charset.defaultCharset())
- val artifactType = JacksonUtils.readValue(definitionContent, ArtifactType::class.java)
- checkNotNull(artifactType) { "failed to get artifact type from file : ${file.name}" }
+ val definition = JacksonUtils.readValue(definitionContent, classType) as EntityType
+ //checkNotNull(definition) { "failed to get data type from file : ${file.name}" }
val modelType = ModelType()
- modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
- modelType.derivedFrom = artifactType.derivedFrom
- modelType.description = artifactType.description
+ val definitionType: String?
+ when (T::class) {
+ DataType::class -> {
+ definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ }
+ RelationshipType::class -> {
+ definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE
+ }
+ ArtifactType::class -> {
+ definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
+ }
+ NodeType::class -> {
+ definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
+ }
+ else -> {
+ throw BluePrintException("couldn't process model type($classType) definition")
+ }
+ }
+ modelType.definitionType = definitionType
+ modelType.derivedFrom = definition.derivedFrom
+ modelType.description = definition.description
modelType.definition = JacksonUtils.jsonNode(definitionContent)
modelType.modelName = dataKey
- modelType.version = artifactType.version
+ modelType.version = definition.version
modelType.updatedBy = updateBySystem
- modelType.tags = (dataKey + "," + artifactType.derivedFrom + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
+ modelType.tags = (dataKey + "," + definition.derivedFrom + "," + definitionType)
modelTypeHandler.saveModel(modelType)
- log.trace("ArtifactType(${file.name}) loaded successfully ")
+ log.trace("${classType.name}(${file.name}) loaded successfully ")
} catch (e: Exception) {
- errorBuilder.appendln("Couldn't load ArtifactType(${file.name}: ${e.message}")
+ errorBuilder.appendln("Couldn't load ${classType.name}(${file.name}: ${e.message}")
}
}
-
- private fun loadNodeType(file: File, errorBuilder: StrBuilder) {
- try {
- log.trace("Loading NodeType(${file.name}")
- val nodeKey = FilenameUtils.getBaseName(file.name)
- val definitionContent = file.readText(Charset.defaultCharset())
- val nodeType = JacksonUtils.readValue(definitionContent, NodeType::class.java)
- checkNotNull(nodeType) { "failed to get node type from file : ${file.name}" }
-
- val modelType = ModelType()
- modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
- modelType.derivedFrom = nodeType.derivedFrom
- modelType.description = nodeType.description
- modelType.definition = JacksonUtils.jsonNode(definitionContent)
- modelType.modelName = nodeKey
- modelType.version = nodeType.version
- modelType.updatedBy = updateBySystem
- modelType.tags = (nodeKey + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE + "," + nodeType.derivedFrom)
- modelTypeHandler.saveModel(modelType)
- log.trace("NodeType(${file.name}) loaded successfully ")
- } catch (e: Exception) {
- errorBuilder.appendln("Couldn't load NodeType(${file.name}: ${e.message}")
- }
- }
-
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.
+ */
+
+package org.onap.ccsdk.apps.controllerblueprints.service.validator
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.data.*
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+
+class ModelTypeValidator {
+ companion object {
+ /**
+ * This is a validateModelTypeDefinition
+ *
+ * @param definitionType definitionType
+ * @param definitionContent definitionContent
+ * @return boolean
+ */
+ fun validateModelTypeDefinition(definitionType: String, definitionContent: JsonNode): Boolean {
+
+ when (definitionType) {
+ BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE -> {
+ JacksonUtils.readValue(definitionContent, DataType::class.java)
+ ?: throw BluePrintException("Model type definition is not DataType valid content $definitionContent")
+ }
+ BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE -> {
+ JacksonUtils.readValue(definitionContent, NodeType::class.java)
+ ?: throw BluePrintException("Model type definition is not NodeType valid content $definitionContent")
+ }
+ BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE -> {
+ JacksonUtils.readValue(definitionContent, ArtifactType::class.java)
+ ?: throw BluePrintException("Model type definition is not ArtifactType valid content $definitionContent")
+ }
+ BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE -> {
+ JacksonUtils.readValue(definitionContent, CapabilityDefinition::class.java)
+ ?: throw BluePrintException("Model type definition is not CapabilityDefinition valid content $definitionContent")
+ }
+ BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE -> {
+ JacksonUtils.readValue(definitionContent, RelationshipType::class.java)
+ ?: throw BluePrintException("Model type definition is not RelationshipType valid content $definitionContent")
+ }
+ }
+ return true
+ }
+
+ /**
+ * This is a validateModelType method
+ *
+ * @param modelType modelType
+ * @return boolean
+ */
+ fun validateModelType(modelType: ModelType?): Boolean {
+ checkNotNull(modelType) { "Model Type Information is missing." }
+
+ val validRootTypes = BluePrintTypes.validModelTypes()
+
+ check(validRootTypes.contains(modelType.definitionType)) {
+ "Not Valid Model Root Type(${modelType.definitionType}), It should be $validRootTypes"
+ }
+
+ validateModelTypeDefinition(modelType.definitionType, modelType.definition)
+ return true
+ }
+ }
+
+}
+++ /dev/null
-/*
- * Copyright © 2017-2018 AT&T Intellectual Property.
- *
- * 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.
- */
-
-package org.onap.ccsdk.apps.controllerblueprints.service.enhancer;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.onap.ccsdk.apps.controllerblueprints.TestApplication;
-import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintEnhancerService;
-import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintValidatorService;
-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext;
-import org.onap.ccsdk.apps.controllerblueprints.service.load.ModelTypeLoadService;
-import org.onap.ccsdk.apps.controllerblueprints.service.load.ResourceDictionaryLoadService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.TestPropertySource;
-import org.springframework.test.context.junit4.SpringRunner;
-
-import java.nio.file.Paths;
-
-@RunWith(SpringRunner.class)
-@ContextConfiguration(classes = {TestApplication.class})
-@TestPropertySource(locations = {"classpath:application.properties"})
-public class BluePrintEnhancerServiceImplTest {
-
- @Autowired
- private ModelTypeLoadService modelTypeLoadService;
-
- @Autowired
- private ResourceDictionaryLoadService resourceDictionaryLoadService;
-
- @Autowired
- private BluePrintEnhancerService bluePrintEnhancerService;
-
- @Autowired
- private BluePrintValidatorService bluePrintValidatorService;
-
- @Before
- public void init() {
- modelTypeLoadService.loadPathModelType("./../../../../components/model-catalog/definition-type/starter-type");
- resourceDictionaryLoadService.loadPathResourceDictionary("./../../../../components/model-catalog/resource-dictionary/starter-dictionary");
- }
-
- @Test
- public void testEnhancementAndValidation() throws Exception {
-
- String basePath = "./../../../../components/model-catalog/blueprint-model/starter-blueprint/baseconfiguration";
-
- String targetPath = Paths.get("target", "bp-enhance").toUri().getPath();
-
- BluePrintContext bluePrintContext = bluePrintEnhancerService.enhance(basePath, targetPath);
- Assert.assertNotNull("failed to get blueprintContext ", bluePrintContext);
-
- // Validate the Generated BluePrints
- Boolean valid = bluePrintValidatorService.validateBluePrints(targetPath);
- Assert.assertTrue("blueprint validation failed ", valid);
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright © 2018 IBM.
- *
- * 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.
- */
-
-package org.onap.ccsdk.apps.controllerblueprints.service.validator;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException;
-import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType;
-
-public class ModelTypeValidatorTest {
-
- @Before
- public void setup(){
- ModelTypeValidator modelTypeValidator;
- }
-
- @Test
- public void testGetValidModelDefinitionType_definitionContentNULL() throws Exception{
- String definitionType=null;
- JsonNode definitionContent=null;
- boolean valid= ModelTypeValidator.validateModelTypeDefinition(definitionType, definitionContent);
- Assert.assertTrue(valid);
-
- }
-
- @Test(expected=BluePrintException.class)
- public void testvalidateModelType() throws Exception{
- ModelType modelType = new ModelType();
- modelType.setDefinitionType("");
- modelType.setDerivedFrom("");
- modelType.setDescription("");
- JsonNode definitionContent=null;
- modelType.setDefinition(definitionContent);
- modelType.setModelName("");
- modelType.setVersion("");
- modelType.setTags("");
- modelType.setUpdatedBy("");
- ModelTypeValidator.validateModelType(modelType);
- }
-}
--- /dev/null
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.
+ */
+
+package org.onap.ccsdk.apps.controllerblueprints.service.enhancer
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.onap.ccsdk.apps.controllerblueprints.TestApplication
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintEnhancerService
+import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintValidatorService
+import org.onap.ccsdk.apps.controllerblueprints.service.load.ModelTypeLoadService
+import org.onap.ccsdk.apps.controllerblueprints.service.load.ResourceDictionaryLoadService
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.test.context.ContextConfiguration
+import org.springframework.test.context.TestPropertySource
+import org.springframework.test.context.junit4.SpringRunner
+import java.nio.file.Paths
+
+@RunWith(SpringRunner::class)
+@ContextConfiguration(classes = arrayOf(TestApplication::class))
+@TestPropertySource(locations = arrayOf("classpath:application.properties"))
+class BluePrintEnhancerServiceImplTest {
+
+ @Autowired
+ private val modelTypeLoadService: ModelTypeLoadService? = null
+
+ @Autowired
+ private val resourceDictionaryLoadService: ResourceDictionaryLoadService? = null
+
+ @Autowired
+ private val bluePrintEnhancerService: BluePrintEnhancerService? = null
+
+ @Autowired
+ private val bluePrintValidatorService: BluePrintValidatorService? = null
+
+ @Before
+ fun init() {
+ runBlocking {
+ modelTypeLoadService!!.loadPathModelType("./../../../../components/model-catalog/definition-type/starter-type")
+ resourceDictionaryLoadService!!.loadPathResourceDictionary("./../../../../components/model-catalog/resource-dictionary/starter-dictionary")
+ }
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun testEnhancementAndValidation() {
+
+ val basePath = "./../../../../components/model-catalog/blueprint-model/starter-blueprint/baseconfiguration"
+
+ val targetPath = Paths.get("target", "bp-enhance").toUri().path
+
+ val bluePrintContext = bluePrintEnhancerService!!.enhance(basePath, targetPath)
+ Assert.assertNotNull("failed to get blueprintContext ", bluePrintContext)
+
+ // Validate the Generated BluePrints
+ val valid = bluePrintValidatorService!!.validateBluePrints(targetPath)
+ Assert.assertTrue("blueprint validation failed ", valid)
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.
+ */
+
+package org.onap.ccsdk.apps.controllerblueprints.service.validator
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.junit.Test
+import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
+
+class ModelTypeValidatorTest {
+
+ @Test(expected = IllegalStateException::class)
+ @Throws(Exception::class)
+ fun testvalidateModelType() {
+ val modelType = ModelType()
+ modelType.definitionType = ""
+ modelType.derivedFrom = ""
+ modelType.description = ""
+ val definitionContent: JsonNode? = null
+ modelType.definition = definitionContent
+ modelType.modelName = ""
+ modelType.version = ""
+ modelType.tags = ""
+ modelType.updatedBy = ""
+ ModelTypeValidator.validateModelType(modelType)
+ }
+}
Code Review / ccsdk / cds.git / commitdiff