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 org.junit.Assert;
  20 import org.junit.Before;
  21 import org.junit.BeforeClass;
  22 import org.junit.Rule;
  23 import org.junit.Test;
  24 import org.junit.rules.ExpectedException;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.Mock;
  27 import org.mockito.MockitoAnnotations;
  28 import org.mockito.runners.MockitoJUnitRunner;
  29 import org.onap.sdc.tosca.datatypes.model.OperationDefinitionType;
  30 import org.openecomp.sdc.common.errors.CoreException;
  31 import org.openecomp.sdc.tosca.TestUtil;
  32 import org.openecomp.sdc.tosca.datatypes.ToscaElementTypes;
  33 import org.openecomp.sdc.tosca.datatypes.ToscaFlatData;
  34 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  35 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  36 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  37 import org.onap.sdc.tosca.datatypes.model.NodeType;
  38 import org.onap.sdc.tosca.datatypes.model.ParameterDefinition;
  39 import org.onap.sdc.tosca.datatypes.model.PropertyDefinition;
  40 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  41 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
  42 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  43 import org.onap.sdc.tosca.datatypes.model.SubstitutionMapping;
  44 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
  45 import org.onap.sdc.tosca.datatypes.model.CapabilityDefinition;
  46 import org.onap.sdc.tosca.datatypes.model.Import;
  47 import org.openecomp.sdc.tosca.services.DataModelUtil;
  48 import org.onap.sdc.tosca.datatypes.model.InterfaceType;
  49 import org.onap.sdc.tosca.datatypes.model.InterfaceDefinitionType;
  50 import org.onap.sdc.tosca.datatypes.model.DataType;
  51 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  52 import org.openecomp.sdc.tosca.services.ToscaConstants;
  53 import org.onap.sdc.tosca.datatypes.model.DefinitionOfDataType;
  54
  55 import java.io.InputStream;
  56 import java.util.ArrayList;
  57 import java.util.HashMap;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Optional;
  61 import java.io.IOException;
  62
  63 import static org.junit.Assert.assertFalse;
  64 import static org.junit.Assert.assertNotNull;
  65 import static org.junit.Assert.assertTrue;
  66 import static org.mockito.Mockito.when;
  67 import static org.junit.Assert.assertEquals;
  68
  69 import org.onap.sdc.tosca.services.ToscaExtensionYamlUtil;
  70
  71
  72 @RunWith(MockitoJUnitRunner.class)
  73 public class ToscaAnalyzerServiceImplTest {
  74     /*
  75     Dictionary:
  76     SrvTmp: ServiceTemplate
  77     NdTmp: NodeTemplate
  78     NdTy: NodeType
  79     */
  80
  81     private static ToscaAnalyzerService toscaAnalyzerService;
  82     private static ToscaServiceModel toscaServiceModel;
  83     @Rule
  84     public ExpectedException thrown = ExpectedException.none();
  85
  86     @Mock
  87     private NodeTemplate nodeTemplateMock;
  88     @Mock
  89     private ParameterDefinition parameterDefinitionMock;
  90     @Mock
  91     private PropertyDefinition propertyDefinitionMock;
  92     @Mock
  93     private InterfaceDefinitionType interfaceDefinitionMock;
  94     @Mock
  95     private ToscaServiceModel toscaServiceModelMock;
  96
  97     @BeforeClass
  98     public static void onlyOnceSetUp() throws IOException {
  99         toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 100         toscaServiceModel = TestUtil.loadToscaServiceModel("/mock/analyzerService/toscasubstitution/",
 101                 "/mock/globalServiceTemplates/", null);
 102     }
 103
 104     @Before
 105     public void init() throws IOException {
 106         MockitoAnnotations.initMocks(this);
 107     }
 108
 109     @Test
 110     public void testGetFlatEntityNotFound() throws Exception {
 111         thrown.expect(CoreException.class);
 112         thrown.expectMessage(
 113                 "Entity Type 'org.openecomp.resource.vfc.notFound' or one of its derivedFrom type hierarchy, is not defined in tosca service model");
 114         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 115         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 116                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 117
 118             ServiceTemplate serviceTemplateFromYaml =
 119                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 120
 121             toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE, "org.openecomp.resource.vfc.notFound",
 122                     serviceTemplateFromYaml, toscaServiceModel);
 123         }
 124     }
 125
 126     @Test
 127     public void testGetFlatEntityFileNotFound() throws Exception {
 128         thrown.expect(CoreException.class);
 129         thrown.expectMessage("Tosca file 'missingFile.yaml' was not found in tosca service model");
 130         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 131         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 132                 "/mock/analyzerService/ServiceTemplateFileNotFoundTest.yaml")) {
 133
 134             ServiceTemplate serviceTemplateFromYaml =
 135                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 136
 137             toscaAnalyzerService
 138                     .getFlatEntity(ToscaElementTypes.NODE_TYPE, "org.openecomp.resource.vfc.nodes.heat.cmaui_image",
 139                             serviceTemplateFromYaml, toscaServiceModel);
 140         }
 141     }
 142
 143     @Test
 144     public void testGetFlatEntityNodeType() throws Exception {
 145         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 146         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 147                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 148
 149             ServiceTemplate serviceTemplateFromYaml =
 150                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 151
 152             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE,
 153                     "org.openecomp.resource.vfc.nodes.heat" + ".cmaui_image", serviceTemplateFromYaml,
 154                     toscaServiceModel);
 155
 156             Assert.assertNotNull(flatData);
 157             checkNodeTypeFlatEntity(flatData);
 158             checkNodeTypeInheritanceHierarchy(flatData);
 159         }
 160     }
 161
 162     private void checkNodeTypeInheritanceHierarchy(ToscaFlatData flatData) {
 163         List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 164         Assert.assertNotNull(inheritanceHierarchyType);
 165         Assert.assertEquals(4, inheritanceHierarchyType.size());
 166         Assert.assertEquals(true,
 167                 inheritanceHierarchyType.contains("org.openecomp.resource.vfc.nodes.heat.cmaui_image"));
 168         Assert.assertEquals(true,
 169                 inheritanceHierarchyType.contains("org.openecomp.resource.vfc.nodes.heat.nova.Server"));
 170         Assert.assertEquals(true, inheritanceHierarchyType.contains("tosca.nodes.Compute"));
 171         Assert.assertEquals(true, inheritanceHierarchyType.contains("tosca.nodes.Root"));
 172     }
 173
 174     private void checkNodeTypeFlatEntity(ToscaFlatData flatData) {
 175         Assert.assertNotNull(flatData.getFlatEntity());
 176         NodeType flatEntity = (NodeType) flatData.getFlatEntity();
 177         Assert.assertEquals("org.openecomp.resource.vfc.nodes.heat.nova.Server", flatEntity.getDerived_from());
 178         Assert.assertEquals(20, flatEntity.getProperties().size());
 179         Assert.assertEquals("overridden default value", flatEntity.getProperties().get("admin_pass").get_default());
 180         Assert.assertEquals("REBUILD", flatEntity.getProperties().get("image_update_policy").get_default());
 181         Assert.assertNotNull(flatEntity.getProperties().get("new_property"));
 182     }
 183
 184     @Test
 185     public void testGetFlatEntityNodeTypeInterface() throws Exception {
 186         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 187         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 188                 "/mock/analyzerService/ServiceTemplateInterfaceInheritanceTest.yaml")) {
 189
 190             ServiceTemplate serviceTemplateFromYaml =
 191                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 192
 193             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE,
 194                     "org.openecomp.resource.vfc.nodes.heat.cmaui_image_extend", serviceTemplateFromYaml,
 195                     toscaServiceModel);
 196
 197             Assert.assertNotNull(flatData);
 198             Assert.assertNotNull(flatData.getFlatEntity());
 199             NodeType flatEntity = (NodeType) flatData.getFlatEntity();
 200             Assert.assertNotNull(flatEntity.getInterfaces());
 201             Object standardInterfaceObj = flatEntity.getInterfaces().get("Standard");
 202             Assert.assertNotNull(standardInterfaceObj);
 203             Optional<InterfaceDefinitionType> standardInterface = DataModelUtil
 204                                                                           .convertObjToInterfaceDefinition("Standard",
 205                                                                                   standardInterfaceObj,
 206                                                                                   InterfaceDefinitionType.class);
 207             Assert.assertEquals(true, standardInterface.isPresent());
 208             Assert.assertEquals(2, standardInterface.get().getInputs().size());
 209             Assert.assertEquals(3, standardInterface.get().getOperations().size());
 210             OperationDefinitionType createOperation = toscaExtensionYamlUtil.yamlToObject(
 211                     toscaExtensionYamlUtil.objectToYaml(standardInterface.get().getOperations().get("create")),
 212                     OperationDefinitionType.class);
 213             Assert.assertEquals(2, createOperation.getInputs().size());
 214
 215             List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 216             Assert.assertNotNull(inheritanceHierarchyType);
 217             Assert.assertEquals(5, inheritanceHierarchyType.size());
 218         }
 219     }
 220
 221
 222     @Test
 223     public void testGetFlatEntityDataType() throws Exception {
 224         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 225         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 226                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 227
 228             ServiceTemplate serviceTemplateFromYaml =
 229                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 230
 231             ToscaFlatData flatData = toscaAnalyzerService.getFlatEntity(ToscaElementTypes.DATA_TYPE,
 232                     "org.openecomp.datatypes.heat.network.MyNewAddressPair", serviceTemplateFromYaml,
 233                     toscaServiceModel);
 234
 235             Assert.assertNotNull(flatData);
 236             Assert.assertNotNull(flatData.getFlatEntity());
 237             DataType flatEntity = (DataType) flatData.getFlatEntity();
 238             Assert.assertEquals("org.openecomp.datatypes.heat.network.MyAddressPair", flatEntity.getDerived_from());
 239             Assert.assertEquals(3, flatEntity.getProperties().size());
 240             Assert.assertEquals("overridden default value",
 241                     flatEntity.getProperties().get("mac_address").get_default());
 242             Assert.assertEquals(true, flatEntity.getProperties().get("mac_address").getRequired());
 243             Assert.assertNotNull(flatEntity.getProperties().get("new_property"));
 244
 245             List<String> inheritanceHierarchyType = flatData.getInheritanceHierarchyType();
 246             Assert.assertNotNull(inheritanceHierarchyType);
 247             Assert.assertEquals(4, inheritanceHierarchyType.size());
 248         }
 249     }
 250
 251     @Test
 252     public void testCalculateExposedRequirements() throws Exception {
 253         RequirementDefinition rd = new RequirementDefinition();
 254         rd.setCapability("tosca.capabilities.Node");
 255         rd.setNode("tosca.nodes.Root");
 256         rd.setRelationship("tosca.relationships.DependsOn");
 257         Object[] occurences = new Object[] {0, "UNBOUNDED"};
 258         rd.setOccurrences(occurences);
 259
 260         RequirementDefinition rd1 = new RequirementDefinition();
 261         rd.setCapability("tosca.capabilities.network.Bindable");
 262         rd.setNode(null);
 263         rd.setRelationship("tosca.relationships.network.BindsTo");
 264         Object[] occurences1 = new Object[] {1, 1};
 265         rd1.setOccurrences(occurences1);
 266
 267         Map<String, RequirementDefinition> nodeTypeRequirementDefinition = new HashMap<>();
 268         nodeTypeRequirementDefinition.put("binding", rd1);
 269         nodeTypeRequirementDefinition.put("dependency", rd);
 270
 271         Map<String, Map<String, RequirementAssignment>> fullFilledRequirementsDefinition = new HashMap<>();
 272         RequirementAssignment ra = new RequirementAssignment();
 273         ra.setCapability("tosca.capabilities.network.Bindable");
 274         ra.setNode("pd_server");
 275         ra.setRelationship("tosca.relationships.network.BindsTo");
 276         Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
 277         nodeTemplateRequirementsAssignment.put("binding", ra);
 278
 279         List<Map<String, RequirementDefinition>> nodeTypeRequirementsDefinition = new ArrayList<>();
 280         nodeTypeRequirementsDefinition.add(nodeTypeRequirementDefinition);
 281
 282         List<Map<String, RequirementDefinition>> exposedRequirements = toscaAnalyzerService
 283                                                                                .calculateExposedRequirements(
 284                                                                                        nodeTypeRequirementsDefinition,
 285                                                                                        nodeTemplateRequirementsAssignment);
 286         Assert.assertEquals(1, exposedRequirements.size());
 287     }
 288
 289     @Test
 290     public void testCalExpReqWithNullNodeInReqAssignment() throws Exception {
 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         RequirementDefinition rd1 = new RequirementDefinition();
 299         rd.setCapability("tosca.capabilities.network.Bindable");
 300         rd.setNode(null);
 301         rd.setRelationship("tosca.relationships.network.BindsTo");
 302         Object[] occurences1 = new Object[] {1, 1};
 303         rd1.setOccurrences(occurences1);
 304
 305         Map<String, RequirementDefinition> nodeTypeRequirementDefinition = new HashMap<>();
 306         nodeTypeRequirementDefinition.put("binding", rd1);
 307         nodeTypeRequirementDefinition.put("dependency", rd);
 308
 309         Map<String, Map<String, RequirementAssignment>> fullFilledRequirementsDefinition = new HashMap<>();
 310         RequirementAssignment ra = new RequirementAssignment();
 311         ra.setCapability("tosca.capabilities.network.Bindable");
 312         ra.setNode(null);
 313         ra.setRelationship("tosca.relationships.network.BindsTo");
 314         Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
 315         nodeTemplateRequirementsAssignment.put("binding", ra);
 316
 317         List<Map<String, RequirementDefinition>> nodeTypeRequirementsDefinition = new ArrayList<>();
 318         nodeTypeRequirementsDefinition.add(nodeTypeRequirementDefinition);
 319
 320         List<Map<String, RequirementDefinition>> exposedRequirements = toscaAnalyzerService
 321                                                                                .calculateExposedRequirements(
 322                                                                                        nodeTypeRequirementsDefinition,
 323                                                                                        nodeTemplateRequirementsAssignment);
 324         Assert.assertEquals(1, exposedRequirements.size());
 325     }
 326
 327     @Test
 328     public void testCalculateExposedCapabilities() throws Exception {
 329         Map<String, CapabilityDefinition> nodeTypeCapabilitiesDefinition = new HashMap<>();
 330         CapabilityDefinition cd = new CapabilityDefinition();
 331         cd.setType("tosca.capabilities.Scalable");
 332         nodeTypeCapabilitiesDefinition.put("tosca.capabilities.network.Bindable_pd_server", cd);
 333         Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
 334         RequirementAssignment ra = new RequirementAssignment();
 335         ra.setCapability("tosca.capabilities.network.Bindable");
 336         ra.setNode("pd_server");
 337         ra.setRelationship("tosca.relationships.network.BindsTo");
 338         nodeTemplateRequirementsAssignment.put("binding", ra);
 339         Map<String, Map<String, RequirementAssignment>> fullFilledRequirementsDefinition = new HashMap<>();
 340         fullFilledRequirementsDefinition.put("pd_server", nodeTemplateRequirementsAssignment);
 341         Map<String, CapabilityDefinition> exposedCapabilities = toscaAnalyzerService.calculateExposedCapabilities(
 342                 nodeTypeCapabilitiesDefinition, fullFilledRequirementsDefinition);
 343         Assert.assertEquals(1, exposedCapabilities.size());
 344     }
 345
 346     @Test
 347     public void testIsRequirementExistsWithInvalidReqId() throws Exception {
 348         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 349         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 350                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 351
 352             ServiceTemplate serviceTemplateFromYaml =
 353                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 354
 355             TestUtil.createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml, toscaExtensionYamlUtil);
 356
 357
 358             RequirementAssignment ra = new RequirementAssignment();
 359             ra.setCapability("tosca.capabilities.network.Bindable");
 360             ra.setNode("server_cmaui");
 361             ra.setRelationship("tosca.relationships.network.BindsTo");
 362
 363             NodeTemplate port0 =
 364                     serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui_port_0");
 365             //Test With Empty requirementId
 366             Assert.assertEquals(false, toscaAnalyzerService.isRequirementExistInNodeTemplate(port0, "", ra));
 367
 368             //Test With valid requirementId
 369             Assert.assertEquals(true, toscaAnalyzerService.isRequirementExistInNodeTemplate(port0, "binding", ra));
 370
 371             //Test With invalid requirement assignment
 372             RequirementAssignment ra1 = new RequirementAssignment();
 373             ra1.setCapability("tosca.capabilities.network.Bindable1");
 374             ra1.setNode("server_cmaui1");
 375             ra1.setRelationship("tosca.relationships.network.BindsTo1");
 376             Assert.assertEquals(false, toscaAnalyzerService.isRequirementExistInNodeTemplate(port0, "binding", ra1));
 377         }
 378     }
 379
 380     @Test
 381     public void testGetRequirements() throws Exception {
 382         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 383         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 384                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 385
 386             ServiceTemplate serviceTemplateFromYaml =
 387                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 388
 389             NodeTemplate port0 =
 390                     serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui_port_0");
 391             List<RequirementAssignment> reqList =
 392                     toscaAnalyzerService.getRequirements(port0, ToscaConstants.BINDING_REQUIREMENT_ID);
 393             assertEquals(1, reqList.size());
 394
 395             reqList.clear();
 396             NodeTemplate port1 =
 397                     serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui1_port_1");
 398             reqList = toscaAnalyzerService.getRequirements(port1, ToscaConstants.LINK_REQUIREMENT_ID);
 399             assertEquals(2, reqList.size());
 400
 401             reqList.clear();
 402             reqList = toscaAnalyzerService.getRequirements(port0, ToscaConstants.LINK_REQUIREMENT_ID);
 403             assertEquals(0, reqList.size());
 404         }
 405     }
 406
 407     @Test
 408     public void testGetNodeTemplateById() throws Exception {
 409         ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
 410         Optional<NodeTemplate> nodeTemplate =
 411                 toscaAnalyzerService.getNodeTemplateById(emptyServiceTemplate, "test_net222");
 412         assertEquals(false, nodeTemplate.isPresent());
 413
 414         ServiceTemplate mainServiceTemplate =
 415                 toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 416         nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
 417         assertEquals(true, nodeTemplate.isPresent());
 418
 419         nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net222");
 420         assertEquals(false, nodeTemplate.isPresent());
 421     }
 422
 423     @Test
 424     public void testGetSubstituteServiceTemplateName() throws Exception {
 425         thrown.expect(CoreException.class);
 426         thrown.expectMessage(
 427                 "Invalid Substitute Node Template invalid2, mandatory map property service_template_filter with mandatory key substitute_service_template must be defined.");
 428
 429         Optional<String> substituteServiceTemplateName;
 430
 431         ServiceTemplate mainServiceTemplate =
 432                 toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 433         Optional<NodeTemplate> notSubstitutableNodeTemplate =
 434                 toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
 435         assertEquals(true, notSubstitutableNodeTemplate.isPresent());
 436
 437         if (notSubstitutableNodeTemplate.isPresent()) {
 438             substituteServiceTemplateName = toscaAnalyzerService.getSubstituteServiceTemplateName("test_net",
 439                     notSubstitutableNodeTemplate.get());
 440             assertEquals(false, substituteServiceTemplateName.isPresent());
 441         }
 442
 443         Optional<NodeTemplate> substitutableNodeTemplate =
 444                 toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_nested");
 445         assertEquals(true, substitutableNodeTemplate.isPresent());
 446         if (substitutableNodeTemplate.isPresent()) {
 447             substituteServiceTemplateName = toscaAnalyzerService.getSubstituteServiceTemplateName("test_nested",
 448                     substitutableNodeTemplate.get());
 449             assertEquals(true, substituteServiceTemplateName.isPresent());
 450             assertEquals("nestedServiceTemplate.yaml", substituteServiceTemplateName.get());
 451         }
 452
 453         NodeTemplate invalidSubstitutableNodeTemplate1 = new NodeTemplate();
 454         substituteServiceTemplateName =
 455                 toscaAnalyzerService.getSubstituteServiceTemplateName("invalid1", invalidSubstitutableNodeTemplate1);
 456         assertEquals(false, substituteServiceTemplateName.isPresent());
 457
 458         substitutableNodeTemplate.ifPresent(nodeTemplate -> {
 459             Object serviceTemplateFilter =
 460                     nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
 461             ((Map) serviceTemplateFilter).clear();
 462             toscaAnalyzerService.getSubstituteServiceTemplateName("invalid2", nodeTemplate);
 463
 464         });
 465     }
 466
 467
 468     @Test
 469     public void testGetSubstitutableNodeTemplates() throws Exception {
 470         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 471         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 472                 "/mock/analyzerService/ServiceTemplateSubstituteTest.yaml")) {
 473             ServiceTemplate serviceTemplateFromYaml =
 474                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 475
 476             Map<String, NodeTemplate> substitutableNodeTemplates =
 477                     toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplateFromYaml);
 478             assertEquals(2, substitutableNodeTemplates.size());
 479             assertNotNull(substitutableNodeTemplates.get("test_nested1"));
 480             assertNotNull(substitutableNodeTemplates.get("test_nested2"));
 481
 482             ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
 483             emptyServiceTemplate.setTopology_template(new TopologyTemplate());
 484             substitutableNodeTemplates = toscaAnalyzerService.getSubstitutableNodeTemplates(emptyServiceTemplate);
 485             assertEquals(0, substitutableNodeTemplates.size());
 486         }
 487
 488         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 489                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 490             ServiceTemplate serviceTemplateFromYaml =
 491                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 492             Map<String, NodeTemplate> substitutableNodeTemplates =
 493                     toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplateFromYaml);
 494             assertEquals(0, substitutableNodeTemplates.size());
 495         }
 496     }
 497
 498     @Test
 499     public void testGetSubstitutionMappedNodeTemplateByExposedReq() throws Exception {
 500         thrown.expect(CoreException.class);
 501         thrown.expectMessage(
 502                 "Invalid Tosca model data, missing 'Node Template' entry for 'Node Template' id cmaui_port_9");
 503         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 504         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 505                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 506             ServiceTemplate nestedServiceTemplateFromYaml =
 507                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 508
 509             Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate = toscaAnalyzerService
 510                                                                                    .getSubstitutionMappedNodeTemplateByExposedReq(
 511                                                                                            "NestedServiceTemplateSubstituteTest.yaml",
 512                                                                                            nestedServiceTemplateFromYaml,
 513                                                                                            "local_storage_server_cmaui");
 514             assertEquals(true, mappedNodeTemplate.isPresent());
 515             mappedNodeTemplate.ifPresent(stringNodeTemplateEntry -> {
 516                 assertEquals("server_cmaui", stringNodeTemplateEntry.getKey());
 517                 assertNotNull(stringNodeTemplateEntry.getValue());
 518             });
 519
 520             mappedNodeTemplate = toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 521                     "NestedServiceTemplateSubstituteTest.yaml", nestedServiceTemplateFromYaml,
 522                     "link_cmaui_port_invalid");
 523             assertEquals(true, mappedNodeTemplate.isPresent());
 524             mappedNodeTemplate.ifPresent(stringNodeTemplateEntry -> {
 525                 assertEquals("server_cmaui", stringNodeTemplateEntry.getKey());
 526                 assertNotNull(stringNodeTemplateEntry.getValue());
 527             });
 528
 529             ServiceTemplate mainServiceTemplate =
 530                     toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 531             mappedNodeTemplate = toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 532                     toscaServiceModel.getEntryDefinitionServiceTemplate(), mainServiceTemplate,
 533                     "local_storage_server_cmaui");
 534             assertEquals(false, mappedNodeTemplate.isPresent());
 535         }
 536     }
 537
 538     @Test
 539     public void invalidSubstitutableMapping() throws Exception {
 540         thrown.expect(CoreException.class);
 541         thrown.expectMessage(
 542                 "Invalid Substitution Service Template invalidMappingServiceTemplate.yaml, missing mandatory file 'Node type' in substitution mapping.");
 543         ServiceTemplate invalidMappingServiceTemplate = new ServiceTemplate();
 544         invalidMappingServiceTemplate.setTopology_template(new TopologyTemplate());
 545         invalidMappingServiceTemplate.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
 546         toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq("invalidMappingServiceTemplate.yaml",
 547                 invalidMappingServiceTemplate, "local_storage_server_cmaui");
 548     }
 549
 550     @Test
 551     public void substitutableMappingWithNoReqMap() throws Exception {
 552         ServiceTemplate emptyReqMapping = new ServiceTemplate();
 553         emptyReqMapping.setTopology_template(new TopologyTemplate());
 554         emptyReqMapping.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
 555         emptyReqMapping.getTopology_template().getSubstitution_mappings().setNode_type("temp");
 556         ServiceTemplate mainServiceTemplate =
 557                 toscaServiceModel.getServiceTemplates().get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 558         Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate = toscaAnalyzerService
 559                                                                                .getSubstitutionMappedNodeTemplateByExposedReq(
 560                                                                                        toscaServiceModel
 561                                                                                                .getEntryDefinitionServiceTemplate(),
 562                                                                                        mainServiceTemplate,
 563                                                                                        "local_storage_server_cmaui");
 564         assertEquals(false, mappedNodeTemplate.isPresent());
 565     }
 566
 567     @Test
 568     public void testGetSubstitutionMappedNodeTemplateByExposedReqInvalid() throws Exception {
 569         thrown.expect(CoreException.class);
 570         thrown.expectMessage(
 571                 "Invalid Tosca model data, missing 'Node Template' entry for 'Node Template' id cmaui_port_9");
 572         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 573         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(
 574                 "/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 575             ServiceTemplate nestedServiceTemplateFromYaml =
 576                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 577
 578             toscaAnalyzerService
 579                     .getSubstitutionMappedNodeTemplateByExposedReq("NestedServiceTemplateSubstituteTest.yaml",
 580                             nestedServiceTemplateFromYaml, "link_cmaui_port_invalid");
 581         }
 582     }
 583
 584     @Test
 585     public void testIsDesiredRequirementAssignmentMatch() throws Exception {
 586
 587         RequirementAssignment requirementAssignment = new RequirementAssignment();
 588         String capability = "Test.Capability";
 589         String node = "Test.node";
 590         String relationship = "Test.relationship";
 591         requirementAssignment.setCapability(capability);
 592         requirementAssignment.setNode(node);
 593         requirementAssignment.setRelationship(relationship);
 594
 595         assertEquals(true, toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, node,
 596                 relationship));
 597         assertEquals(true,
 598                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, node, relationship));
 599         assertEquals(true, toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, null,
 600                 relationship));
 601         assertEquals(true,
 602                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, node, null));
 603         assertEquals(true,
 604                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, null, relationship));
 605         assertEquals(true,
 606                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, null, null));
 607         assertEquals(true,
 608                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, node, null));
 609
 610     }
 611
 612     @Test
 613     public void testIsDesiredRequirementAssignmentNoMatch() throws Exception {
 614
 615         RequirementAssignment requirementAssignment = new RequirementAssignment();
 616         String capability = "Test.Capability";
 617         String node = "Test.node";
 618         String relationship = "Test.relationship";
 619         requirementAssignment.setCapability(capability);
 620         requirementAssignment.setNode(node);
 621         requirementAssignment.setRelationship(relationship);
 622
 623         assertEquals(false,
 624                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", node, relationship));
 625         assertEquals(false,
 626                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", "no", relationship));
 627         assertEquals(false,
 628                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", "no", "no"));
 629         assertEquals(false, toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, "no",
 630                 relationship));
 631         assertEquals(false,
 632                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, node, "no"));
 633         assertEquals(false,
 634                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, capability, "no", "no"));
 635         assertEquals(false,
 636                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, "no", null, null));
 637         assertEquals(false,
 638                 toscaAnalyzerService.isDesiredRequirementAssignment(requirementAssignment, null, null, null));
 639
 640
 641     }
 642
 643     @Test
 644     public void shouldReturnFalseIfNdTmpIsNull() {
 645         NodeTemplate nodeTemplate = null;
 646         assertFalse(toscaAnalyzerService.isTypeOf(nodeTemplate, ToscaNodeType.NATIVE_NETWORK, new ServiceTemplate(),
 647                 toscaServiceModelMock));
 648     }
 649
 650     @Test
 651     public void shouldReturnTrueIfNdTmpTypeIsOfRequestedType() {
 652         NodeTemplate nodeTemplate = new NodeTemplate();
 653         String nodeTypeToSearch = ToscaNodeType.NATIVE_BLOCK_STORAGE;
 654         nodeTemplate.setType(nodeTypeToSearch);
 655         assertTrue(toscaAnalyzerService
 656                            .isTypeOf(nodeTemplate, nodeTypeToSearch, new ServiceTemplate(), toscaServiceModelMock));
 657     }
 658
 659     @Test
 660     public void shouldReturnTrueIfDataTypeIsOfRequestedType() {
 661         PropertyDefinition propertyDefinition = new PropertyDefinition();
 662         String propertyTypeToSearch = "tosca.datatypes.TimeInterval";
 663         propertyDefinition.setType(propertyTypeToSearch);
 664         assertTrue(toscaAnalyzerService.isTypeOf(propertyDefinition, propertyTypeToSearch, new ServiceTemplate(),
 665                 toscaServiceModelMock));
 666     }
 667
 668     @Test
 669     public void shouldReturnTrueIfInterfaceTypeIsOfRequestedType() {
 670         InterfaceDefinitionType interfaceDefinition = new InterfaceDefinitionType();
 671         String interfaceTypeToSearch = "test.interface.A";
 672         interfaceDefinition.setType(interfaceTypeToSearch);
 673         assertTrue(toscaAnalyzerService.isTypeOf(interfaceDefinition, interfaceTypeToSearch, new ServiceTemplate(),
 674                 toscaServiceModelMock));
 675     }
 676
 677     @Test
 678     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyAndNdTyDerivedFromRequestedType() {
 679         String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 680         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 681         Map<String, NodeType> stNodeTypes = new HashMap<>();
 682         addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 683         NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 684         addNodeType(stNodeTypes, typeToMatch, nodeType);
 685         ServiceTemplate serviceTemplate = new ServiceTemplate();
 686         serviceTemplate.setNode_types(stNodeTypes);
 687         assertTrue(toscaAnalyzerService.isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, serviceTemplate,
 688                 toscaServiceModelMock));
 689
 690     }
 691
 692     @Test
 693     public void dataTypeParameterExistInHierarchy() {
 694         String testedDataTypeKey = "test.dataType.B";
 695         when(parameterDefinitionMock.getType()).thenReturn(testedDataTypeKey);
 696         dataTypeExistInHierarchy(testedDataTypeKey, parameterDefinitionMock);
 697
 698     }
 699
 700     @Test
 701     public void dataTypePropertyExistInHierarchy() {
 702         String testedDataTypeKey = "test.dataType.B";
 703         when(propertyDefinitionMock.getType()).thenReturn(testedDataTypeKey);
 704         dataTypeExistInHierarchy(testedDataTypeKey, propertyDefinitionMock);
 705     }
 706
 707     private void dataTypeExistInHierarchy(String testedDataTypeKey, DefinitionOfDataType testedDefinitionDataType) {
 708         String typeToMatch = "test.dataType.A";
 709         Map<String, DataType> stDataTypes = new HashMap<>();
 710         addDataType(stDataTypes, "tosca.datatypes.network.NetworkInfo", new DataType());
 711         DataType testedDataType = createDataType(typeToMatch);
 712         addDataType(stDataTypes, testedDataTypeKey, testedDataType);
 713         ServiceTemplate serviceTemplate = new ServiceTemplate();
 714         serviceTemplate.setData_types(stDataTypes);
 715         assertTrue(toscaAnalyzerService
 716                            .isTypeOf(testedDefinitionDataType, typeToMatch, serviceTemplate, toscaServiceModelMock));
 717     }
 718
 719     @Test
 720     public void interfaceTypeExistInHierarchy() {
 721         String typeToMatch = "test.interfaceType.A";
 722         String testedInterfaceTypeKey = "test.interfaceType.B";
 723         when(interfaceDefinitionMock.getType()).thenReturn(testedInterfaceTypeKey);
 724         Map<String, Object> stInterfaceTypes = new HashMap<>();
 725         stInterfaceTypes.put("tosca.interfaces.network.NetworkInfo", new InterfaceType());
 726         InterfaceType testedInterfaceType = createInterfaceType(typeToMatch);
 727         stInterfaceTypes.put(testedInterfaceTypeKey, testedInterfaceType);
 728         ServiceTemplate serviceTemplate = new ServiceTemplate();
 729         serviceTemplate.setInterface_types(stInterfaceTypes);
 730         assertTrue(toscaAnalyzerService.isTypeOf(interfaceDefinitionMock, "test.interfaceType.A", serviceTemplate,
 731                 toscaServiceModelMock));
 732     }
 733
 734     @Test
 735     public void shouldThrowCoreExceptionForInvalidNodeType() {
 736         thrown.expect(CoreException.class);
 737         thrown.expectMessage("Entity Type 'AAA' or one of its derivedFrom type hierarchy, is not defined in "
 738                                      + "tosca service model");
 739         when(nodeTemplateMock.getType()).thenReturn("AAA");
 740         Map<String, NodeType> stNodeTypes = new HashMap<>();
 741         addNodeType(stNodeTypes, "notImportant", new NodeType());
 742         ServiceTemplate serviceTemplate = new ServiceTemplate();
 743         serviceTemplate.setNode_types(stNodeTypes);
 744         toscaAnalyzerService
 745                 .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_COMPUTE, serviceTemplate, toscaServiceModelMock);
 746     }
 747
 748     @Test
 749     public void shouldThrowCoreExceptionForInvalidNodeType2Level() {
 750         thrown.expect(CoreException.class);
 751         thrown.expectMessage(
 752                 "Entity Type 'A' or one of its derivedFrom type hierarchy, is not defined in tosca " + "service model");
 753         String typeToMatch = "A";
 754         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 755         Map<String, NodeType> stNodeTypes = new HashMap<>();
 756         addNodeType(stNodeTypes, "notImportant", new NodeType());
 757         addNodeType(stNodeTypes, "A", createNodeType("ADerivedFromB"));
 758         addNodeType(stNodeTypes, "ADerivedFromB'", createNodeType("BDerivedFromC"));
 759         ServiceTemplate serviceTemplate = new ServiceTemplate();
 760         serviceTemplate.setNode_types(stNodeTypes);
 761         assertTrue(toscaAnalyzerService
 762                            .isTypeOf(nodeTemplateMock, "BDerivedFromC", serviceTemplate, toscaServiceModelMock));
 763     }
 764
 765     @Test
 766     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyAndNotDerivedFromRequestedTypeBut2ndLevelDerivedFromMatch() {
 767         String typeToMatch = "A";
 768         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 769         Map<String, NodeType> stNodeTypes = new HashMap<>();
 770         addNodeType(stNodeTypes, "notImportant", new NodeType());
 771         addNodeType(stNodeTypes, "A", createNodeType("ADerivedFromB"));
 772         addNodeType(stNodeTypes, "ADerivedFromB", createNodeType("BDerivedFromC"));
 773         ServiceTemplate serviceTemplate = new ServiceTemplate();
 774         serviceTemplate.setNode_types(stNodeTypes);
 775         assertTrue(toscaAnalyzerService
 776                            .isTypeOf(nodeTemplateMock, "BDerivedFromC", serviceTemplate, toscaServiceModelMock));
 777     }
 778
 779     private NodeType createNodeType(String derivedFrom) {
 780         NodeType nodeType = new NodeType();
 781         nodeType.setDerived_from(derivedFrom);
 782         return nodeType;
 783     }
 784
 785     private DataType createDataType(String derivedFrom) {
 786         DataType dataType = new DataType();
 787         dataType.setDerived_from(derivedFrom);
 788         return dataType;
 789     }
 790
 791     private InterfaceType createInterfaceType(String derivedFrom) {
 792         InterfaceType interfaceType = new InterfaceType();
 793         interfaceType.setDerived_from(derivedFrom);
 794         return interfaceType;
 795     }
 796
 797     private void addNodeType(Map<String, NodeType> stNodeTypes, String key, NodeType nodeType) {
 798         stNodeTypes.put(key, nodeType);
 799     }
 800
 801     private void addDataType(Map<String, DataType> stDataTypes, String key, DataType dataType) {
 802         stDataTypes.put(key, dataType);
 803     }
 804
 805     @Test
 806     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyButRequestedTypeNotMatchButFoundIn1stLevelImports() {
 807         String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 808         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 809         List<Map<String, Import>> imports = new ArrayList<>();
 810         Map<String, Import> importMap = new HashMap<>();
 811         Import anImport = new Import();
 812         anImport.setFile("mainImport");
 813         importMap.put("bla bla", anImport);
 814         imports.add(importMap);
 815         ServiceTemplate mainST = new ServiceTemplate();
 816         mainST.setImports(imports);
 817
 818         //create searchable service template
 819         Map<String, NodeType> stNodeTypes = new HashMap<>();
 820         addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 821         NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 822         addNodeType(stNodeTypes, typeToMatch, nodeType);
 823         ServiceTemplate serviceTemplate = new ServiceTemplate();
 824         serviceTemplate.setNode_types(stNodeTypes);
 825
 826         // add service templates to tosca service model
 827         Map<String, ServiceTemplate> serviceTemplates = toscaServiceModelMock.getServiceTemplates();
 828         serviceTemplates.put("testMainServiceTemplate", mainST);
 829         serviceTemplates.put("mainImport", serviceTemplate);
 830         when(toscaServiceModelMock.getServiceTemplates()).thenReturn(serviceTemplates);
 831
 832         assertTrue(toscaAnalyzerService.isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainST,
 833                 toscaServiceModelMock));
 834     }
 835
 836     @Test
 837     public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyButRequestedTypeNotMatchButFoundIn2ndLevelImports() {
 838         String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 839         when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 840         List<Map<String, Import>> imports = new ArrayList<>();
 841         Map<String, Import> importMap = new HashMap<>();
 842         Import anImport = new Import();
 843         anImport.setFile("refToMainImport");
 844         importMap.put("bla bla", anImport);
 845         imports.add(importMap);
 846         ServiceTemplate mainST = new ServiceTemplate();
 847         mainST.setImports(imports);
 848
 849         //create searchable service template
 850         Map<String, NodeType> stNodeTypes = new HashMap<>();
 851         addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 852         NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 853         addNodeType(stNodeTypes, typeToMatch, nodeType);
 854         ServiceTemplate serviceTemplate = new ServiceTemplate();
 855         serviceTemplate.setNode_types(stNodeTypes);
 856
 857         // create 1st level service template with import only
 858         List<Map<String, Import>> firstLevelImports = new ArrayList<>();
 859         Map<String, Import> firstLevelImportsMap = new HashMap<>();
 860         Import firstLevelImport = new Import();
 861         firstLevelImport.setFile("mainImport");
 862         firstLevelImportsMap.put("bla bla 2", firstLevelImport);
 863         firstLevelImports.add(firstLevelImportsMap);
 864         ServiceTemplate firstLevelST = new ServiceTemplate();
 865         firstLevelST.setImports(firstLevelImports);
 866
 867         // add service templates to tosca service model
 868         Map<String, ServiceTemplate> serviceTemplates = toscaServiceModelMock.getServiceTemplates();
 869         serviceTemplates.put("testMainServiceTemplate", mainST);
 870         serviceTemplates.put("refToMainImport", firstLevelST);
 871         serviceTemplates.put("mainImport", serviceTemplate);
 872         when(toscaServiceModelMock.getServiceTemplates()).thenReturn(serviceTemplates);
 873
 874         assertTrue(toscaAnalyzerService.isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainST,
 875                 toscaServiceModelMock));
 876     }
 877
 878     // not found at all should throw core exception
 879
 880 }