gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.tosca.services.impl;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertFalse;
  21 import static org.junit.Assert.assertNotNull;
  22 import static org.junit.Assert.assertTrue;
  23 import static org.mockito.Mockito.when;
  24
  25 import java.io.IOException;
  26 import java.io.InputStream;
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Optional;
  33
  34 import org.junit.Assert;
  35 import org.junit.Before;
  36 import org.junit.BeforeClass;
  37 import org.junit.Rule;
  38 import org.junit.Test;
  39 import org.junit.rules.ExpectedException;
  40 import org.junit.runner.RunWith;
  41 import org.mockito.Mock;
  42 import org.mockito.MockitoAnnotations;
  43 import org.mockito.runners.MockitoJUnitRunner;
  44 import org.onap.sdc.tosca.datatypes.model.CapabilityDefinition;
  45 import org.onap.sdc.tosca.datatypes.model.CapabilityType;
  46 import org.onap.sdc.tosca.datatypes.model.Constraint;
  47 import org.onap.sdc.tosca.datatypes.model.DataType;
  48 import org.onap.sdc.tosca.datatypes.model.DefinitionOfDataType;
  49 import org.onap.sdc.tosca.datatypes.model.Import;
  50 import org.onap.sdc.tosca.datatypes.model.InterfaceDefinitionType;
  51 import org.onap.sdc.tosca.datatypes.model.InterfaceType;
  52 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  53 import org.onap.sdc.tosca.datatypes.model.NodeType;
  54 import org.onap.sdc.tosca.datatypes.model.OperationDefinitionType;
  55 import org.onap.sdc.tosca.datatypes.model.ParameterDefinition;
  56 import org.onap.sdc.tosca.datatypes.model.PropertyDefinition;
  57 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  58 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
  59 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  60 import org.onap.sdc.tosca.datatypes.model.Status;
  61 import org.onap.sdc.tosca.datatypes.model.SubstitutionMapping;
  62 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
  63 import org.onap.sdc.tosca.services.ToscaExtensionYamlUtil;
  64 import org.openecomp.sdc.common.errors.CoreException;
  65 import org.openecomp.sdc.common.errors.SdcRuntimeException;
  66 import org.openecomp.sdc.tosca.TestUtil;
  67 import org.openecomp.sdc.tosca.datatypes.ToscaElementTypes;
  68 import org.openecomp.sdc.tosca.datatypes.ToscaFlatData;
  69 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  70 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  71 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  72 import org.openecomp.sdc.tosca.services.ToscaConstants;
  73
  74
  75 @RunWith(MockitoJUnitRunner.class)
  76 public class ToscaAnalyzerServiceImplTest {
  77
  78     private static final String CAPABILITY_TYPE_A = "capabilityTypeA";
  79     private static final String CAPABILITY_TYPE_B = "capabilityTypeB";
  80     private static final String TOSCA_CAPABILITIES_ROOT = "tosca.capabilities.Root";
  81     private static final String CMAUI_IMAGE_EXTEND = "org.openecomp.resource.vfc.nodes.heat.cmaui_image_extend";
  82     private static final String STANDARD_INTERFACE_KEY = "Standard";
  83     private static final String TOSCA_LIFECYCLE_STANDARD = "tosca.interfaces.node.lifecycle.Standard";
  84     private static final String CMAUI_INTERFACE_TEST =
  85             "org.openecomp.resource.vfc.nodes.heat.cmaui_image_interfaceTest";
  86
  87     /*
  88     Dictionary:
  89     SrvTmp: ServiceTemplate
  90     NdTmp: NodeTemplate
  91     NdTy: NodeType
  92     */
  93
  94     private static ToscaAnalyzerService toscaAnalyzerService;
  95     private static ToscaServiceModel toscaServiceModel;
  96     @Rule
  97     public ExpectedException thrown = ExpectedException.none();
  98
  99     @Mock
 100     private NodeTemplate nodeTemplateMock;
 101     @Mock
 102     private ParameterDefinition parameterDefinitionMock;
 103     @Mock
 104     private PropertyDefinition propertyDefinitionMock;
 105     @Mock
 106     private InterfaceDefinitionType interfaceDefinitionMock;
 107     @Mock
 108     private ToscaServiceModel toscaServiceModelMock;
 109
 110     @BeforeClass
 111     public static void onlyOnceSetUp() throws IOException {
 112         toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 113         toscaServiceModel = TestUtil.loadToscaServiceModel("/mock/analyzerService/toscasubstitution/",
 114                 "/mock/globalServiceTemplates/", null);
 115     }
 116
 117     @Before
 118     public void init() {
 119         MockitoAnnotations.initMocks(this);
 120     }
 121
 122     @Test
 123     public void testGetFlatEntityNotFound() throws Exception {
 124         thrown.expect(CoreException.class);
 125         thrown.expectMessage(
 126                 "Entity Type 'org.openecomp.resource.vfc.notFound' or one of its derivedFrom type "
 127                         + "hierarchy, is not defined in tosca service model");
 128         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 129         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 130                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 131
 132             ServiceTemplate serviceTemplateFromYaml =
 133                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 134
 135             toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE, "org.openecomp.resource.vfc.notFound",
 136                     serviceTemplateFromYaml, toscaServiceModel);
 137         }
 138     }
 139
 140     @Test
 141     public void testGetFlatEntityFileNotFound() throws Exception {
 142         thrown.expect(CoreException.class);
 143         thrown.expectMessage("Tosca file 'missingFile.yaml' was not found in tosca service model");
 144         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 145         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 146                 "/mock/analyzerService/ServiceTemplateFileNotFoundTest.yaml")) {
 147
 148             ServiceTemplate serviceTemplateFromYaml =
 149                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 150
 151             toscaAnalyzerService
 152                     .getFlatEntity(ToscaElementTypes.NODE_TYPE, "org.openecomp.resource.vfc.nodes.heat.cmaui_image",
 153                             serviceTemplateFromYaml, toscaServiceModel);
 154         }
 155     }
 156
 157     @Test
 158     public void testGetFlatEntityNodeType() throws Exception {
 159         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 160         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 161                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 162
 163             ServiceTemplate serviceTemplateFromYaml =
 164                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 165
 166             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE,
 167                     "org.openecomp.resource.vfc.nodes.heat" + ".cmaui_image", serviceTemplateFromYaml,
 168                     toscaServiceModel);
 169
 170             Assert.assertNotNull(flatData);
 171             checkNodeTypeFlatEntity(flatData);
 172             checkNodeTypeInheritanceHierarchy(flatData);
 173         }
 174     }
 175
 176     private void checkNodeTypeInheritanceHierarchy(ToscaFlatData flatData) {
 177         List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 178         Assert.assertNotNull(inheritanceHierarchyType);
 179         Assert.assertEquals(4, inheritanceHierarchyType.size());
 180         Assert.assertTrue(inheritanceHierarchyType.contains("org.openecomp.resource.vfc.nodes.heat.cmaui_image"));
 181         Assert.assertTrue(inheritanceHierarchyType.contains("org.openecomp.resource.vfc.nodes.heat.nova.Server"));
 182         Assert.assertTrue(inheritanceHierarchyType.contains("tosca.nodes.Compute"));
 183         Assert.assertTrue(inheritanceHierarchyType.contains("tosca.nodes.Root"));
 184     }
 185
 186     private void checkNodeTypeFlatEntity(ToscaFlatData flatData) {
 187         Assert.assertNotNull(flatData.getFlatEntity());
 188         NodeType flatEntity = (NodeType) flatData.getFlatEntity();
 189         Assert.assertEquals("org.openecomp.resource.vfc.nodes.heat.nova.Server", flatEntity.getDerived_from());
 190         Assert.assertEquals(20, flatEntity.getProperties().size());
 191         Assert.assertEquals("overridden default value", flatEntity.getProperties().get("admin_pass").get_default());
 192         Assert.assertEquals("REBUILD", flatEntity.getProperties().get("image_update_policy").get_default());
 193         Assert.assertNotNull(flatEntity.getProperties().get("new_property"));
 194     }
 195
 196     @Test
 197     public void testGetFlatEntityNodeTypeInterface() throws Exception {
 198         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 199         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 200                 "/mock/analyzerService/ServiceTemplateInterfaceInheritanceTest.yaml")) {
 201
 202             ServiceTemplate serviceTemplateFromYaml =
 203                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 204
 205             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE, CMAUI_IMAGE_EXTEND,
 206                     serviceTemplateFromYaml, toscaServiceModel);
 207
 208             Assert.assertNotNull(flatData);
 209             Assert.assertNotNull(flatData.getFlatEntity());
 210             NodeType flatEntity = (NodeType) flatData.getFlatEntity();
 211             Assert.assertNotNull(flatEntity.getInterfaces());
 212             Object standardInterfaceObj = flatEntity.getInterfaces().get(STANDARD_INTERFACE_KEY);
 213             Assert.assertNotNull(standardInterfaceObj);
 214             InterfaceDefinitionType standardInterface = new InterfaceDefinitionType(standardInterfaceObj);
 215             Assert.assertEquals(2, standardInterface.getInputs().size());
 216             Assert.assertEquals(3, standardInterface.getOperations().size());
 217             OperationDefinitionType createOperation = toscaExtensionYamlUtil.yamlToObject(
 218                     toscaExtensionYamlUtil.objectToYaml(standardInterface.getOperations().get("create")),
 219                     OperationDefinitionType.class);
 220             Assert.assertEquals(2, createOperation.getInputs().size());
 221
 222             List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 223             Assert.assertNotNull(inheritanceHierarchyType);
 224             Assert.assertEquals(5, inheritanceHierarchyType.size());
 225         }
 226     }
 227
 228
 229     @Test
 230     public void testGetFlatEntityDataType() throws Exception {
 231         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 232         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 233                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 234
 235             ServiceTemplate serviceTemplateFromYaml =
 236                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 237
 238             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.DATA_TYPE,
 239                     "org.openecomp.datatypes.heat.network.MyNewAddressPair", serviceTemplateFromYaml,
 240                     toscaServiceModel);
 241
 242             Assert.assertNotNull(flatData);
 243             Assert.assertNotNull(flatData.getFlatEntity());
 244             DataType flatEntity = (DataType) flatData.getFlatEntity();
 245             Assert.assertEquals("org.openecomp.datatypes.heat.network.MyAddressPair", flatEntity.getDerived_from());
 246             Assert.assertEquals(3, flatEntity.getProperties().size());
 247             Assert.assertEquals("overridden default value",
 248                     flatEntity.getProperties().get("mac_address").get_default());
 249             Assert.assertEquals(true, flatEntity.getProperties().get("mac_address").getRequired());
 250             Assert.assertNotNull(flatEntity.getProperties().get("new_property"));
 251
 252             List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 253             Assert.assertNotNull(inheritanceHierarchyType);
 254             Assert.assertEquals(4, inheritanceHierarchyType.size());
 255         }
 256     }
 257
 258     @Test
 259     public void testGetFlatEntityDataTypeDerivedFromPrimitive() throws Exception {
 260         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 261         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 262                 "/mock/analyzerService/ServiceTemplateDatatypeFlatTest.yaml")) {
 263
 264             ServiceTemplate serviceTemplateFromYaml =
 265                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 266
 267             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.DATA_TYPE,
 268                     "org.openecomp.datatypes.heat.network.MyNewString", serviceTemplateFromYaml, toscaServiceModel);
 269
 270             Assert.assertNotNull(flatData);
 271             Assert.assertNotNull(flatData.getFlatEntity());
 272             DataType flatEntity = (DataType) flatData.getFlatEntity();
 273             Assert.assertEquals("org.openecomp.datatypes.heat.network.MyString", flatEntity.getDerived_from());
 274             Assert.assertEquals(2, flatEntity.getConstraints().size());
 275             Assert.assertNotNull(flatEntity.getConstraints().get(0).getValid_values());
 276             Assert.assertNotNull(flatEntity.getConstraints().get(1).getMax_length());
 277
 278             List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 279             Assert.assertNotNull(inheritanceHierarchyType);
 280             Assert.assertEquals(2, inheritanceHierarchyType.size());
 281         }
 282     }
 283
 284     @Test
 285     public void testCalculateExposedRequirementsNull() {
 286         assertTrue(toscaAnalyzerService.calculateExposedRequirements(null, null).isEmpty());
 287     }
 288
 289     @Test
 290     public void testCalculateExposedRequirements() {
 291         RequirementDefinition rd = new RequirementDefinition();
 292         rd.setCapability("tosca.capabilities.Node");
 293         rd.setNode("tosca.nodes.Root");
 294         rd.setRelationship("tosca.relationships.DependsOn");
 295         Object[] occurences = new Object[] {0, "UNBOUNDED"};
 296         rd.setOccurrences(occurences);
 297
 298         rd.setCapability("tosca.capabilities.network.Bindable");
 299         rd.setNode(null);
 300         rd.setRelationship("tosca.relationships.network.BindsTo");
 301         Object[] occurences1 = new Object[] {1, 1};
 302         RequirementDefinition rd1 = new RequirementDefinition();
 303         rd1.setOccurrences(occurences1);
 304
 305         Map<String, RequirementDefinition> nodeTypeRequirementDefinition = new HashMap<>();
 306         nodeTypeRequirementDefinition.put("binding", rd1);
 307         nodeTypeRequirementDefinition.put("dependency", rd);
 308
 309         RequirementAssignment ra = new RequirementAssignment();
 310         ra.setCapability("tosca.capabilities.network.Bindable");
 311         ra.setNode("pd_server");
 312         ra.setRelationship("tosca.relationships.network.BindsTo");
 313         Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
 314         nodeTemplateRequirementsAssignment.put("binding", ra);
 315
 316         List<Map<String, RequirementDefinition>> nodeTypeRequirementsDefinition = new ArrayList<>();
 317         nodeTypeRequirementsDefinition.add(nodeTypeRequirementDefinition);
 318
 319         List<Map<String, RequirementDefinition>> exposedRequirements = toscaAnalyzerService
 320                 .calculateExposedRequirements(
 321                         nodeTypeRequirementsDefinition,
 322                         nodeTemplateRequirementsAssignment);
 323         Assert.assertEquals(1, exposedRequirements.size());
 324     }
 325
 326     @Test
 327     public void testCalExpReqWithNullNodeInReqAssignment() {
 328         RequirementDefinition rd = new RequirementDefinition();
 329         rd.setCapability("tosca.capabilities.Node");
 330         rd.setNode("tosca.nodes.Root");
 331         rd.setRelationship("tosca.relationships.DependsOn");
 332         Object[] occurences = new Object[] {0, "UNBOUNDED"};
 333         rd.setOccurrences(occurences);
 334
 335         rd.setCapability("tosca.capabilities.network.Bindable");
 336         rd.setNode(null);
 337         rd.setRelationship("tosca.relationships.network.BindsTo");
 338         Object[] occurences1 = new Object[] {1, 1};
 339         RequirementDefinition rd1 = new RequirementDefinition();
 340         rd1.setOccurrences(occurences1);
 341
 342         Map<String, RequirementDefinition> nodeTypeRequirementDefinition = new HashMap<>();
 343         nodeTypeRequirementDefinition.put("binding", rd1);
 344         nodeTypeRequirementDefinition.put("dependency", rd);
 345
 346         RequirementAssignment ra = new RequirementAssignment();
 347         ra.setCapability("tosca.capabilities.network.Bindable");
 348         ra.setNode(null);
 349         ra.setRelationship("tosca.relationships.network.BindsTo");
 350         Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
 351         nodeTemplateRequirementsAssignment.put("binding", ra);
 352
 353         List<Map<String, RequirementDefinition>> nodeTypeRequirementsDefinition = new ArrayList<>();
 354         nodeTypeRequirementsDefinition.add(nodeTypeRequirementDefinition);
 355
 356         List<Map<String, RequirementDefinition>> exposedRequirements = toscaAnalyzerService
 357                 .calculateExposedRequirements(
 358                         nodeTypeRequirementsDefinition,
 359                         nodeTemplateRequirementsAssignment);
 360         Assert.assertEquals(1, exposedRequirements.size());
 361     }
 362
 363     @Test
 364     public void testCalculateExposedCapabilities() {
 365         Map<String, CapabilityDefinition> nodeTypeCapabilitiesDefinition = new HashMap<>();
 366         CapabilityDefinition cd = new CapabilityDefinition();
 367         cd.setType("tosca.capabilities.Scalable");
 368         nodeTypeCapabilitiesDefinition.put("tosca.capabilities.network.Bindable_pd_server", cd);
 369         RequirementAssignment ra = new RequirementAssignment();
 370         ra.setCapability("tosca.capabilities.network.Bindable");
 371         ra.setNode("pd_server");
 372         ra.setRelationship("tosca.relationships.network.BindsTo");
 373         Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
 374         nodeTemplateRequirementsAssignment.put("binding", ra);
 375         Map<String, Map<String, RequirementAssignment>> fullFilledRequirementsDefinition = new HashMap<>();
 376         fullFilledRequirementsDefinition.put("pd_server", nodeTemplateRequirementsAssignment);
 377         Map<String, CapabilityDefinition> exposedCapabilities = toscaAnalyzerService.calculateExposedCapabilities(
 378                 nodeTypeCapabilitiesDefinition, fullFilledRequirementsDefinition);
 379         Assert.assertEquals(1, exposedCapabilities.size());
 380     }
 381
 382     @Test
 383     public void testIsRequirementExistsWithInvalidReqId() throws Exception {
 384         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 385         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 386                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 387
 388             ServiceTemplate serviceTemplateFromYaml =
 389                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 390
 391             TestUtil.createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml, toscaExtensionYamlUtil);
 392
 393
 394             RequirementAssignment ra = new RequirementAssignment();
 395             ra.setCapability("tosca.capabilities.network.Bindable");
 396             ra.setNode("server_cmaui");
 397             ra.setRelationship("tosca.relationships.network.BindsTo");
 398
 399             NodeTemplate port0 = serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui_port_0");
 400             //Test With Empty requirementId
 401             Assert.assertFalse(toscaAnalyzerService.isRequirementExistInNodeTemplate(port0, "", ra));
 402
 403             //Test With valid requirementId
 404             Assert.assertTrue(toscaAnalyzerService.isRequirementExistInNodeTemplate(port0, "binding", ra));
 405
 406             //Test With invalid requirement assignment
 407             RequirementAssignment ra1 = new RequirementAssignment();
 408             ra1.setCapability("tosca.capabilities.network.Bindable1");
 409             ra1.setNode("server_cmaui1");
 410             ra1.setRelationship("tosca.relationships.network.BindsTo1");
 411             Assert.assertFalse(toscaAnalyzerService.isRequirementExistInNodeTemplate(port0, "binding", ra1));
 412         }
 413     }
 414
 415     @Test
 416     public void testGetRequirements() throws Exception {
 417         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 418         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 419                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 420
 421             ServiceTemplate serviceTemplateFromYaml =
 422                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 423
 424             NodeTemplate port0 = serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui_port_0");
 425             List<RequirementAssignment> reqList =
 426                     toscaAnalyzerService.getRequirements(port0, ToscaConstants.BINDING_REQUIREMENT_ID);
 427             assertEquals(1, reqList.size());
 428
 429             reqList.clear();
 430             NodeTemplate port1 =
 431                     serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui1_port_1");
 432             reqList = toscaAnalyzerService.getRequirements(port1, ToscaConstants.LINK_REQUIREMENT_ID);
 433             assertEquals(2, reqList.size());
 434
 435             reqList.clear();
 436             reqList = toscaAnalyzerService.getRequirements(port0, ToscaConstants.LINK_REQUIREMENT_ID);
 437             assertEquals(0, reqList.size());
 438         }
 439     }
 440
 441     @Test
 442     public void testGetNodeTemplateById() {
 443         ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
 444         Optional<NodeTemplate> nodeTemplate =
 445                 toscaAnalyzerService.getNodeTemplateById(emptyServiceTemplate, "test_net222");
 446         assertFalse(nodeTemplate.isPresent());
 447
 448         ServiceTemplate mainServiceTemplate =
 449                 toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 450         nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
 451         assertTrue(nodeTemplate.isPresent());
 452
 453         nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net222");
 454         assertFalse(nodeTemplate.isPresent());
 455     }
 456
 457     @Test
 458     public void testGetSubstituteServiceTemplateName() {
 459         thrown.expect(CoreException.class);
 460         thrown.expectMessage(
 461                 "Invalid Substitute Node Template invalid2, mandatory map property service_template_filter "
 462                         + "with mandatory key substitute_service_template must be defined.");
 463
 464         Optional<String> substituteServiceTemplateName;
 465
 466         ServiceTemplate mainServiceTemplate =
 467                 toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 468         Optional<NodeTemplate> notSubstitutableNodeTemplate =
 469                 toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
 470         assertTrue(notSubstitutableNodeTemplate.isPresent());
 471
 472         substituteServiceTemplateName = toscaAnalyzerService.getSubstituteServiceTemplateName("test_net",
 473                 notSubstitutableNodeTemplate.get());
 474         assertFalse(substituteServiceTemplateName.isPresent());
 475
 476         Optional<NodeTemplate> substitutableNodeTemplate =
 477                 toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_nested");
 478         assertTrue(substitutableNodeTemplate.isPresent());
 479
 480         substituteServiceTemplateName = toscaAnalyzerService.getSubstituteServiceTemplateName("test_nested",
 481                 substitutableNodeTemplate.get());
 482         assertTrue(substituteServiceTemplateName.isPresent());
 483         assertEquals("nestedServiceTemplate.yaml", substituteServiceTemplateName.get());
 484
 485         NodeTemplate invalidSubstitutableNodeTemplate1 = new NodeTemplate();
 486         substituteServiceTemplateName =
 487                 toscaAnalyzerService.getSubstituteServiceTemplateName("invalid1", invalidSubstitutableNodeTemplate1);
 488         assertFalse(substituteServiceTemplateName.isPresent());
 489
 490         substitutableNodeTemplate.ifPresent(nodeTemplate -> {
 491             Object serviceTemplateFilter =
 492                     nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
 493             ((Map) serviceTemplateFilter).clear();
 494             toscaAnalyzerService.getSubstituteServiceTemplateName("invalid2", nodeTemplate);
 495
 496         });
 497     }
 498
 499
 500     @Test
 501     public void testGetSubstitutableNodeTemplates() throws Exception {
 502         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 503         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 504                 "/mock/analyzerService/ServiceTemplateSubstituteTest.yaml")) {
 505             ServiceTemplate serviceTemplateFromYaml =
 506                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 507
 508             Map<String, NodeTemplate> substitutableNodeTemplates =
 509                     toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplateFromYaml);
 510             assertEquals(2, substitutableNodeTemplates.size());
 511             assertNotNull(substitutableNodeTemplates.get("test_nested1"));
 512             assertNotNull(substitutableNodeTemplates.get("test_nested2"));
 513
 514             ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
 515             emptyServiceTemplate.setTopology_template(new TopologyTemplate());
 516             substitutableNodeTemplates = toscaAnalyzerService.getSubstitutableNodeTemplates(emptyServiceTemplate);
 517             assertEquals(0, substitutableNodeTemplates.size());
 518         }
 519
 520         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 521                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 522             ServiceTemplate serviceTemplateFromYaml =
 523                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 524             Map<String, NodeTemplate> substitutableNodeTemplates =
 525                     toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplateFromYaml);
 526             assertEquals(0, substitutableNodeTemplates.size());
 527         }
 528     }
 529
 530     @Test
 531     public void testGetSubstitutionMappedNodeTemplateByExposedReq() throws Exception {
 532         thrown.expect(CoreException.class);
 533         thrown.expectMessage(
 534                 "Invalid Tosca model data, missing 'Node Template' entry for 'Node Template' id cmaui_port_9");
 535         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 536         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 537                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 538             ServiceTemplate nestedServiceTemplateFromYaml =
 539                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 540
 541             Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate =
 542                     toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 543                             "NestedServiceTemplateSubstituteTest.yaml",
 544                             nestedServiceTemplateFromYaml,
 545                             "local_storage_server_cmaui");
 546
 547             assertTrue(mappedNodeTemplate.isPresent());
 548             mappedNodeTemplate.ifPresent(stringNodeTemplateEntry -> {
 549                 assertEquals("server_cmaui", stringNodeTemplateEntry.getKey());
 550                 assertNotNull(stringNodeTemplateEntry.getValue());
 551             });
 552
 553             mappedNodeTemplate = toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 554                     "NestedServiceTemplateSubstituteTest.yaml", nestedServiceTemplateFromYaml,
 555                     "link_cmaui_port_invalid");
 556             assertTrue(mappedNodeTemplate.isPresent());
 557             mappedNodeTemplate.ifPresent(stringNodeTemplateEntry -> {
 558                 assertEquals("server_cmaui", stringNodeTemplateEntry.getKey());
 559                 assertNotNull(stringNodeTemplateEntry.getValue());
 560             });
 561
 562             ServiceTemplate mainServiceTemplate =
 563                     toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 564             mappedNodeTemplate = toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 565                     toscaServiceModel.getEntryDefinitionServiceTemplate(), mainServiceTemplate,
 566                     "local_storage_server_cmaui");
 567             assertFalse(mappedNodeTemplate.isPresent());
 568         }
 569     }
 570
 571     @Test
 572     public void invalidSubstitutableMapping() {
 573         thrown.expect(CoreException.class);
 574         thrown.expectMessage(
 575                 "Invalid Substitution Service Template invalidMappingServiceTemplate.yaml, "
 576                         + "missing mandatory file 'Node type' in substitution mapping.");
 577         ServiceTemplate invalidMappingServiceTemplate = new ServiceTemplate();
 578         invalidMappingServiceTemplate.setTopology_template(new TopologyTemplate());
 579         invalidMappingServiceTemplate.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
 580         toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq("invalidMappingServiceTemplate.yaml",
 581                 invalidMappingServiceTemplate, "local_storage_server_cmaui");
 582     }
 583
 584     @Test
 585     public void substitutableMappingWithNoReqMap() {
 586         ServiceTemplate emptyReqMapping = new ServiceTemplate();
 587         emptyReqMapping.setTopology_template(new TopologyTemplate());
 588         emptyReqMapping.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
 589         emptyReqMapping.getTopology_template().getSubstitution_mappings().setNode_type("temp");
 590         ServiceTemplate mainServiceTemplate =
 591                 toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 592         Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate =
 593                 toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 594                         toscaServiceModel.getEntryDefinitionServiceTemplate(), mainServiceTemplate,
 595                         "local_storage_server_cmaui");
 596         assertFalse(mappedNodeTemplate.isPresent());
 597     }
 598
 599     @Test
 600     public void testGetSubstitutionMappedNodeTemplateByExposedReqInvalid() throws Exception {
 601         thrown.expect(CoreException.class);
 602         thrown.expectMessage(
 603                 "Invalid Tosca model data, missing 'Node Template' entry for 'Node Template' id cmaui_port_9");
 604         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 605         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 606                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 607             ServiceTemplate nestedServiceTemplateFromYaml =
 608                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 609
 610             toscaAnalyzerService
 611                     .getSubstitutionMappedNodeTemplateByExposedReq("NestedServiceTemplateSubstituteTest.yaml",
 612                             nestedServiceTemplateFromYaml, "link_cmaui_port_invalid");
 613         }
 614     }
 615
 616     @Test
 617     public void testIsDesiredRequirementAssignmentMatch() {
 618
 619         RequirementAssignment requirementAssignment = new RequirementAssignment();
 620         String capability = "Test.Capability";
 621         String node = "Test.node";
 622         String relationship = "Test.relationship";
 623         requirementAssignment.setCapability(capability);
 624         requirementAssignment.setNode(node);
 625         requirementAssignment.setRelationship(relationship);
 626
 627         assertTrue(toscaAnalyzerService
 628                 .isDesiredRequirementAssignment(requirementAssignment, capability, node, relationship));
 629         assertTrue(
 630                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, node, relationship));
 631         assertTrue(toscaAnalyzerService
 632                 .isDesiredRequirementAssignment(requirementAssignment, capability, null, relationship));
 633         assertTrue(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, node, null));
 634         assertTrue(
 635                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, null, relationship));
 636         assertTrue(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, null, null));
 637         assertTrue(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, node, null));
 638
 639     }
 640
 641     @Test
 642     public void testIsDesiredRequirementAssignmentNoMatch() {
 643
 644         RequirementAssignment requirementAssignment = new RequirementAssignment();
 645         String capability = "Test.Capability";
 646         String node = "Test.node";
 647         String relationship = "Test.relationship";
 648         requirementAssignment.setCapability(capability);
 649         requirementAssignment.setNode(node);
 650         requirementAssignment.setRelationship(relationship);
 651
 652         assertFalse(
 653                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", node, relationship));
 654         assertFalse(
 655                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", "no", relationship));
 656         assertFalse(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", "no", "no"));
 657         assertFalse(toscaAnalyzerService
 658                 .isDesiredRequirementAssignment(requirementAssignment, capability, "no", relationship));
 659         assertFalse(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, node, "no"));
 660         assertFalse(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, "no", "no"));
 661         assertFalse(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", null, null));
 662         assertFalse(toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, null, null));
 663
 664
 665     }
 666
 667     @Test
 668     public void shouldReturnFalseIfNdTmpIsNull() {
 669         NodeTemplate nodeTemplate = null;
 670         assertFalse(toscaAnalyzerService.isTypeOf(nodeTemplate, ToscaNodeType.NATIVE_NETWORK, new ServiceTemplate(),
 671                 toscaServiceModelMock));
 672     }
 673
 674     @Test
 675     public void shouldReturnTrueIfNdTmpTypeIsOfRequestedType() {
 676         NodeTemplate nodeTemplate = new NodeTemplate();
 677         String nodeTypeToSearch = ToscaNodeType.NATIVE_BLOCK_STORAGE;
 678         nodeTemplate.setType(nodeTypeToSearch);
 679         assertTrue(toscaAnalyzerService
 680                 .isTypeOf(nodeTemplate, nodeTypeToSearch, new ServiceTemplate(), toscaServiceModelMock));
 681     }
 682
 683     @Test
 684     public void shouldReturnTrueIfDataTypeIsOfRequestedType() {
 685         PropertyDefinition propertyDefinition = new PropertyDefinition();
 686         String propertyTypeToSearch = "tosca.datatypes.TimeInterval";
 687         propertyDefinition.setType(propertyTypeToSearch);
 688         assertTrue(toscaAnalyzerService.isTypeOf(propertyDefinition, propertyTypeToSearch, new ServiceTemplate(),
 689                 toscaServiceModelMock));
 690     }
 691
 692     @Test
 693     public void shouldReturnTrueIfInterfaceTypeIsOfRequestedType() {
 694         InterfaceDefinitionType interfaceDefinition = new InterfaceDefinitionType();
 695         String interfaceTypeToSearch = "test.interface.A";
 696         interfaceDefinition.setType(interfaceTypeToSearch);
 697         assertTrue(toscaAnalyzerService.isTypeOf(interfaceDefinition, interfaceTypeToSearch, new ServiceTemplate(),
 698                 toscaServiceModelMock));
 699     }
 700
 701     @Test
 702     public void interfaceInheritanceNoOperIsTypeTrue() throws IOException {
 703         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 704         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 705                 "/mock/analyzerService/ServiceTemplateInterfaceInheritanceTest.yaml")) {
 706             interfaceIsTypeTest(toscaExtensionYamlUtil, CMAUI_IMAGE_EXTEND, yamlFile);
 707         }
 708     }
 709
 710     private void interfaceIsTypeTest(ToscaExtensionYamlUtil toscaExtensionYamlUtil, String nodeTypeKey,
 711                                      InputStream yamlFile) {
 712         ServiceTemplate serviceTemplateFromYaml = toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 713
 714         ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE, nodeTypeKey,
 715                 serviceTemplateFromYaml, toscaServiceModel);
 716
 717         Assert.assertNotNull(flatData);
 718         Object standardInterfaceDefinition =
 719                 ((NodeType) flatData.getFlatEntity()).getInterfaces().get(STANDARD_INTERFACE_KEY);
 720         InterfaceDefinitionType standardInterfaceDefinitionType =
 721                 new InterfaceDefinitionType(standardInterfaceDefinition);
 722         assertTrue(toscaAnalyzerService
 723                 .isTypeOf(standardInterfaceDefinitionType, TOSCA_LIFECYCLE_STANDARD, serviceTemplateFromYaml,
 724                         toscaServiceModel));
 725     }
 726
 727     @Test
 728     public void interfaceInheritanceWithOperIsTypeTrue() throws IOException {
 729         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 730         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 731                 "/mock/analyzerService/ServiceTemplateInterfaceInheritanceTest.yaml")) {
 732             interfaceIsTypeTest(toscaExtensionYamlUtil, CMAUI_INTERFACE_TEST, yamlFile);
 733         }
 734     }
 735
 736
 737     @Test
 738     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyAndNdTyDerivedFromRequestedType() {
 739         String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 740         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 741         Map<String, NodeType> stNodeTypes = new HashMap<>();
 742         addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 743         NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 744         addNodeType(stNodeTypes, typeToMatch, nodeType);
 745         ServiceTemplate serviceTemplate = new ServiceTemplate();
 746         serviceTemplate.setNode_types(stNodeTypes);
 747         assertTrue(toscaAnalyzerService.isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, serviceTemplate,
 748                 toscaServiceModelMock));
 749
 750     }
 751
 752     @Test
 753     public void dataTypeParameterExistInHierarchy() {
 754         String testedDataTypeKey = "test.dataType.B";
 755         when(parameterDefinitionMock.getType()).thenReturn(testedDataTypeKey);
 756         dataTypeExistInHierarchy(testedDataTypeKey, parameterDefinitionMock);
 757
 758     }
 759
 760     @Test
 761     public void dataTypePropertyExistInHierarchy() {
 762         String testedDataTypeKey = "test.dataType.B";
 763         when(propertyDefinitionMock.getType()).thenReturn(testedDataTypeKey);
 764         dataTypeExistInHierarchy(testedDataTypeKey, propertyDefinitionMock);
 765     }
 766
 767     private void dataTypeExistInHierarchy(String testedDataTypeKey, DefinitionOfDataType testedDefinitionDataType) {
 768         String typeToMatch = "test.dataType.A";
 769         Map<String, DataType> stDataTypes = new HashMap<>();
 770         addDataType(stDataTypes, "tosca.datatypes.network.NetworkInfo", new DataType());
 771         DataType testedDataType = createDataType(typeToMatch);
 772         addDataType(stDataTypes, testedDataTypeKey, testedDataType);
 773         ServiceTemplate serviceTemplate = new ServiceTemplate();
 774         serviceTemplate.setData_types(stDataTypes);
 775         assertTrue(toscaAnalyzerService
 776                 .isTypeOf(testedDefinitionDataType, typeToMatch, serviceTemplate, toscaServiceModelMock));
 777     }
 778
 779     @Test
 780     public void interfaceTypeExistInHierarchy() {
 781         String typeToMatch = "test.interfaceType.A";
 782         String testedInterfaceTypeKey = "test.interfaceType.B";
 783         when(interfaceDefinitionMock.getType()).thenReturn(testedInterfaceTypeKey);
 784         Map<String, Object> stInterfaceTypes = new HashMap<>();
 785         stInterfaceTypes.put("tosca.interfaces.network.NetworkInfo", new InterfaceType());
 786         InterfaceType testedInterfaceType = createInterfaceType(typeToMatch);
 787         stInterfaceTypes.put(testedInterfaceTypeKey, testedInterfaceType);
 788         ServiceTemplate serviceTemplate = new ServiceTemplate();
 789         serviceTemplate.setInterface_types(stInterfaceTypes);
 790         assertTrue(toscaAnalyzerService.isTypeOf(interfaceDefinitionMock, "test.interfaceType.A", serviceTemplate,
 791                 toscaServiceModelMock));
 792     }
 793
 794     @Test
 795     public void shouldThrowCoreExceptionForInvalidNodeType() {
 796         thrown.expect(CoreException.class);
 797         thrown.expectMessage("Entity Type 'AAA' or one of its derivedFrom type hierarchy, is not defined in "
 798                 + "tosca service model");
 799         when(nodeTemplateMock.getType()).thenReturn("AAA");
 800         Map<String, NodeType> stNodeTypes = new HashMap<>();
 801         addNodeType(stNodeTypes, "notImportant", new NodeType());
 802         ServiceTemplate serviceTemplate = new ServiceTemplate();
 803         serviceTemplate.setNode_types(stNodeTypes);
 804         toscaAnalyzerService
 805                 .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_COMPUTE, serviceTemplate, toscaServiceModelMock);
 806     }
 807
 808     @Test
 809     public void shouldThrowCoreExceptionForInvalidNodeType2Level() {
 810         thrown.expect(CoreException.class);
 811         thrown.expectMessage(
 812                 "Entity Type 'A' or one of its derivedFrom type hierarchy, is not defined in tosca " + "service model");
 813         String typeToMatch = "A";
 814         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 815         Map<String, NodeType> stNodeTypes = new HashMap<>();
 816         addNodeType(stNodeTypes, "notImportant", new NodeType());
 817         addNodeType(stNodeTypes, "A", createNodeType("ADerivedFromB"));
 818         addNodeType(stNodeTypes, "ADerivedFromB'", createNodeType("BDerivedFromC"));
 819         ServiceTemplate serviceTemplate = new ServiceTemplate();
 820         serviceTemplate.setNode_types(stNodeTypes);
 821         assertTrue(toscaAnalyzerService
 822                 .isTypeOf(nodeTemplateMock, "BDerivedFromC", serviceTemplate, toscaServiceModelMock));
 823     }
 824
 825     @Test
 826     public void
 827     shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyAndNotDerivedFromRequestedTypeBut2ndLevelDerivedFromMatch() {
 828         String typeToMatch = "A";
 829         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 830         Map<String, NodeType> stNodeTypes = new HashMap<>();
 831         addNodeType(stNodeTypes, "notImportant", new NodeType());
 832         addNodeType(stNodeTypes, "A", createNodeType("ADerivedFromB"));
 833         addNodeType(stNodeTypes, "ADerivedFromB", createNodeType("BDerivedFromC"));
 834         ServiceTemplate serviceTemplate = new ServiceTemplate();
 835         serviceTemplate.setNode_types(stNodeTypes);
 836         assertTrue(toscaAnalyzerService
 837                 .isTypeOf(nodeTemplateMock, "BDerivedFromC", serviceTemplate, toscaServiceModelMock));
 838     }
 839
 840     private NodeType createNodeType(String derivedFrom) {
 841         NodeType nodeType = new NodeType();
 842         nodeType.setDerived_from(derivedFrom);
 843         return nodeType;
 844     }
 845
 846     private DataType createDataType(String derivedFrom) {
 847         DataType dataType = new DataType();
 848         dataType.setDerived_from(derivedFrom);
 849         return dataType;
 850     }
 851
 852     private InterfaceType createInterfaceType(String derivedFrom) {
 853         InterfaceType interfaceType = new InterfaceType();
 854         interfaceType.setDerived_from(derivedFrom);
 855         return interfaceType;
 856     }
 857
 858     private void addNodeType(Map<String, NodeType> stNodeTypes, String key, NodeType nodeType) {
 859         stNodeTypes.put(key, nodeType);
 860     }
 861
 862     private void addDataType(Map<String, DataType> stDataTypes, String key, DataType dataType) {
 863         stDataTypes.put(key, dataType);
 864     }
 865
 866     @Test
 867     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyButRequestedTypeNotMatchButFoundIn1stLevelImports() {
 868         String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 869         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 870         List<Map<String, Import>> imports = new ArrayList<>();
 871         Map<String, Import> importMap = new HashMap<>();
 872         Import anImport = new Import();
 873         anImport.setFile("mainImport");
 874         importMap.put("bla bla", anImport);
 875         imports.add(importMap);
 876         ServiceTemplate mainSt = new ServiceTemplate();
 877         mainSt.setImports(imports);
 878
 879         //create searchable service template
 880         Map<String, NodeType> stNodeTypes = new HashMap<>();
 881         addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 882         NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 883         addNodeType(stNodeTypes, typeToMatch, nodeType);
 884         ServiceTemplate serviceTemplate = new ServiceTemplate();
 885         serviceTemplate.setNode_types(stNodeTypes);
 886
 887         // add service templates to tosca service model
 888         Map<String, ServiceTemplate> serviceTemplates = toscaServiceModelMock.getServiceTemplates();
 889         serviceTemplates.put("testMainServiceTemplate", mainSt);
 890         serviceTemplates.put("mainImport", serviceTemplate);
 891         when(toscaServiceModelMock.getServiceTemplates()).thenReturn(serviceTemplates);
 892
 893         assertTrue(toscaAnalyzerService.isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainSt,
 894                 toscaServiceModelMock));
 895     }
 896
 897     @Test
 898     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyButRequestedTypeNotMatchButFoundIn2ndLevelImports() {
 899         String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 900         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 901         List<Map<String, Import>> imports = new ArrayList<>();
 902         Map<String, Import> importMap = new HashMap<>();
 903         Import anImport = new Import();
 904         anImport.setFile("refToMainImport");
 905         importMap.put("bla bla", anImport);
 906         imports.add(importMap);
 907         ServiceTemplate mainSt = new ServiceTemplate();
 908         mainSt.setImports(imports);
 909
 910         //create searchable service template
 911         Map<String, NodeType> stNodeTypes = new HashMap<>();
 912         addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 913         NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 914         addNodeType(stNodeTypes, typeToMatch, nodeType);
 915         ServiceTemplate serviceTemplate = new ServiceTemplate();
 916         serviceTemplate.setNode_types(stNodeTypes);
 917
 918         // create 1st level service template with import only
 919         List<Map<String, Import>> firstLevelImports = new ArrayList<>();
 920         Map<String, Import> firstLevelImportsMap = new HashMap<>();
 921         Import firstLevelImport = new Import();
 922         firstLevelImport.setFile("mainImport");
 923         firstLevelImportsMap.put("bla bla 2", firstLevelImport);
 924         firstLevelImports.add(firstLevelImportsMap);
 925         ServiceTemplate firstLevelSt = new ServiceTemplate();
 926         firstLevelSt.setImports(firstLevelImports);
 927
 928         // add service templates to tosca service model
 929         Map<String, ServiceTemplate> serviceTemplates = toscaServiceModelMock.getServiceTemplates();
 930         serviceTemplates.put("testMainServiceTemplate", mainSt);
 931         serviceTemplates.put("refToMainImport", firstLevelSt);
 932         serviceTemplates.put("mainImport", serviceTemplate);
 933         when(toscaServiceModelMock.getServiceTemplates()).thenReturn(serviceTemplates);
 934
 935         assertTrue(toscaAnalyzerService.isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainSt,
 936                 toscaServiceModelMock));
 937     }
 938
 939     // not found at all should throw core exception
 940
 941
 942     @Test
 943     public void capabilityDefinitionIsTypeOfDirectTypeFound() {
 944         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 945         capabilityDefinition.setType(CAPABILITY_TYPE_A);
 946         assertTrue(toscaAnalyzerService.isTypeOf(capabilityDefinition, CAPABILITY_TYPE_A, new ServiceTemplate(),
 947                 toscaServiceModelMock));
 948     }
 949
 950     @Test
 951     public void capabilityDefinitionIsTypeOfReturnNo() {
 952         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 953         capabilityDefinition.setType(CAPABILITY_TYPE_A);
 954         ServiceTemplate serviceTemplate = new ServiceTemplate();
 955         serviceTemplate.setCapability_types(new HashMap<>());
 956         CapabilityType capabilityType = new CapabilityType();
 957         capabilityType.setDerived_from(TOSCA_CAPABILITIES_ROOT);
 958         serviceTemplate.getCapability_types().put(CAPABILITY_TYPE_A, capabilityType);
 959         assertFalse(toscaAnalyzerService
 960                 .isTypeOf(capabilityDefinition, CAPABILITY_TYPE_B, serviceTemplate, toscaServiceModelMock));
 961     }
 962
 963     @Test
 964     public void capabilityDefinitionIsTypeOfInheritanceTypeFound() {
 965         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 966         capabilityDefinition.setType(CAPABILITY_TYPE_A);
 967         ServiceTemplate serviceTemplate = new ServiceTemplate();
 968         serviceTemplate.setCapability_types(new HashMap<>());
 969         CapabilityType capabilityType = new CapabilityType();
 970         capabilityType.setDerived_from(CAPABILITY_TYPE_B);
 971         serviceTemplate.getCapability_types().put(CAPABILITY_TYPE_A, capabilityType);
 972         assertTrue(toscaAnalyzerService
 973                 .isTypeOf(capabilityDefinition, CAPABILITY_TYPE_B, serviceTemplate, toscaServiceModelMock));
 974     }
 975
 976     @Test
 977     public void testGetNodeTemplatesByTypeNodeTemplateIsEmpty() {
 978         ServiceTemplate serviceTemplate = new ServiceTemplate();
 979         serviceTemplate.setTopology_template(new TopologyTemplate());
 980
 981         assertTrue(toscaAnalyzerService.getNodeTemplatesByType(serviceTemplate, null, null).isEmpty());
 982     }
 983
 984     @Test
 985     public void testGetNodeTemplatesByTypeDifferentType() {
 986         ServiceTemplate serviceTemplate = new ServiceTemplate();
 987         serviceTemplate.setTopology_template(new TopologyTemplate());
 988         serviceTemplate.setNode_types(Collections.singletonMap("nodeType", new NodeType()));
 989
 990         NodeTemplate nodeTemplate = new NodeTemplate();
 991         nodeTemplate.setType("nodeType");
 992
 993         serviceTemplate.getTopology_template().setNode_templates(Collections.singletonMap("node1", nodeTemplate));
 994
 995         assertEquals(0, toscaAnalyzerService.getNodeTemplatesByType(
 996                 serviceTemplate, "nodeType1", new ToscaServiceModel()).size());
 997     }
 998
 999     @Test
1000     public void testGetNodeTemplatesByTypeSameType() {
1001         ServiceTemplate serviceTemplate = new ServiceTemplate();
1002         serviceTemplate.setTopology_template(new TopologyTemplate());
1003
1004         NodeTemplate nodeTemplate = new NodeTemplate();
1005         nodeTemplate.setType("nodeType");
1006
1007         serviceTemplate.getTopology_template().setNode_templates(Collections.singletonMap("node1", nodeTemplate));
1008
1009         assertEquals(1, toscaAnalyzerService.getNodeTemplatesByType(
1010                 serviceTemplate, "nodeType", new ToscaServiceModel()).size());
1011     }
1012
1013     @Test
1014     public void testFetchNodeTypeNodeTypePresent() {
1015         ServiceTemplate serviceTemplate = new ServiceTemplate();
1016         serviceTemplate.setNode_types(Collections.singletonMap("nodeType", new NodeType()));
1017
1018         Optional<NodeType> nodeType =
1019                 toscaAnalyzerService.fetchNodeType("nodeType", Collections.singletonList(serviceTemplate));
1020
1021         assertTrue(nodeType.isPresent());
1022     }
1023
1024     @Test
1025     public void testFetchNodeTypeNodeTypeAbsent() {
1026         ServiceTemplate serviceTemplate = new ServiceTemplate();
1027         serviceTemplate.setNode_types(Collections.singletonMap("nodeType", new NodeType()));
1028
1029         Optional<NodeType> nodeType =
1030                 toscaAnalyzerService.fetchNodeType("nodeTypeAbsent", Collections.singletonList(serviceTemplate));
1031
1032         assertFalse(nodeType.isPresent());
1033     }
1034
1035     @Test
1036     public void testGetFlatEntityForCapability() {
1037         ServiceTemplate serviceTemplate = new ServiceTemplate();
1038         CapabilityType capabilityType = new CapabilityType();
1039         capabilityType.setDescription("Capability");
1040         capabilityType.setVersion("1.0");
1041
1042         serviceTemplate.setCapability_types(Collections.singletonMap("capabilityTypeId", capabilityType));
1043         ToscaFlatData toscaFlatData =
1044                 toscaAnalyzerService.getFlatEntity(ToscaElementTypes.CAPABILITY_TYPE, "capabilityTypeId",
1045                         serviceTemplate, new ToscaServiceModel());
1046
1047         assertNotNull(toscaFlatData);
1048         assertEquals(ToscaElementTypes.CAPABILITY_TYPE, toscaFlatData.getElementType());
1049     }
1050
1051     @Test(expected = CoreException.class)
1052     public void testGetFlatEntityForCapabilityThrowsException() {
1053         ServiceTemplate serviceTemplate = new ServiceTemplate();
1054
1055         CapabilityType capabilityType = new CapabilityType();
1056         capabilityType.setDerived_from("tosca.capabilities.Root");
1057
1058         serviceTemplate.setCapability_types(Collections.singletonMap("capabilityTypeId", capabilityType));
1059
1060         toscaAnalyzerService.getFlatEntity(ToscaElementTypes.CAPABILITY_TYPE, "capabilityTypeId",
1061                 serviceTemplate, new ToscaServiceModel());
1062     }
1063
1064     @Test(expected = CoreException.class)
1065     public void testGetFlatEntityForCapabilityNullThrowsException() {
1066         toscaAnalyzerService.getFlatEntity(ToscaElementTypes.CAPABILITY_TYPE, "capabilityTypeId",
1067                 new ServiceTemplate(), new ToscaServiceModel());
1068     }
1069
1070     @Test
1071     public void testCreateInitSubstitutionNodeType() {
1072         ParameterDefinition parameterDefinitionInput = new ParameterDefinition();
1073         parameterDefinitionInput.setRequired(true);
1074         parameterDefinitionInput.set_default("default");
1075         parameterDefinitionInput.setConstraints(Collections.singletonList(new Constraint()));
1076         parameterDefinitionInput.setStatus(Status.SUPPORTED);
1077
1078         ParameterDefinition parameterDefinitionOutput = new ParameterDefinition();
1079         parameterDefinitionOutput.setStatus(Status.SUPPORTED);
1080
1081         ServiceTemplate serviceTemplate = new ServiceTemplate();
1082         serviceTemplate.setTopology_template(new TopologyTemplate());
1083         serviceTemplate.getTopology_template()
1084                 .setInputs(Collections.singletonMap("parameterDef1", parameterDefinitionInput));
1085         serviceTemplate.getTopology_template()
1086                 .setOutputs(Collections.singletonMap("parameterDef1", parameterDefinitionOutput));
1087
1088         NodeType nodeType = toscaAnalyzerService.createInitSubstitutionNodeType(serviceTemplate, "tosca.nodes.Root");
1089
1090         assertNotNull(nodeType);
1091         assertTrue(nodeType.getProperties().size() ==1
1092                         && nodeType.getAttributes().size() == 1);
1093     }
1094
1095     @Test(expected = CoreException.class)
1096     public void testGetSubstituteServiceTemplateNameThrowsException() {
1097         NodeTemplate nodeTemplate = new NodeTemplate();
1098         nodeTemplate.setDirectives(Collections.singletonList(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE));
1099
1100         toscaAnalyzerService.getSubstituteServiceTemplateName(null, nodeTemplate);
1101     }
1102
1103     @Test(expected = SdcRuntimeException.class)
1104     public void testGetFlatEntityThrowsExceptionIncorrectSwitchProvided() {
1105         toscaAnalyzerService.getFlatEntity(ToscaElementTypes.RELATIONSHIP_TYPE, null, null, null);
1106     }
1107 }
1108