openecomp-be/lib/openecomp-tosca-lib/src/test/java/org/openecomp/sdc/tosca/services/impl/ToscaAnalyzerServiceImplTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.tosca.services.impl;
  22
  23 import org.junit.Before;
  24 import org.junit.BeforeClass;
  25 import org.junit.Rule;
  26 import org.junit.Test;
  27 import org.junit.rules.ExpectedException;
  28 import org.junit.runner.RunWith;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.mockito.runners.MockitoJUnitRunner;
  32 import org.openecomp.sdc.common.errors.CoreException;
  33 import org.openecomp.sdc.tosca.TestUtil;
  34 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  35 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  36 import org.openecomp.sdc.tosca.datatypes.model.Import;
  37 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  38 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  39 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  40 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  41 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  42 import org.openecomp.sdc.tosca.datatypes.model.TopologyTemplate;
  43 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  44 import org.openecomp.sdc.tosca.services.ToscaConstants;
  45 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
  46
  47 import java.io.IOException;
  48 import java.io.InputStream;
  49 import java.util.ArrayList;
  50 import java.util.HashMap;
  51 import java.util.List;
  52 import java.util.Map;
  53 import java.util.Optional;
  54
  55 import static org.junit.Assert.assertEquals;
  56 import static org.junit.Assert.assertFalse;
  57 import static org.junit.Assert.assertNotNull;
  58 import static org.junit.Assert.assertTrue;
  59 import static org.mockito.Mockito.when;
  60
  61
  62 /**
  63  * @author Avrahamg
  64  * @since July 14, 2016
  65  */
  66 @RunWith(MockitoJUnitRunner.class)
  67 public class ToscaAnalyzerServiceImplTest {
  68     /*
  69     Dictionary:
  70     SrvTmp: ServiceTemplate
  71     NdTmp: NodeTemplate
  72     NdTy: NodeType
  73     */
  74
  75   private static ToscaAnalyzerService toscaAnalyzerService;
  76   private static ToscaServiceModel toscaServiceModel;
  77   @Rule
  78   public ExpectedException thrown = ExpectedException.none();
  79
  80   @Mock
  81   private NodeTemplate nodeTemplateMock;
  82   @Mock
  83   private ToscaServiceModel toscaServiceModelMock;
  84
  85   @BeforeClass
  86   public static void onlyOnceSetUp() throws IOException {
  87     toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
  88     toscaServiceModel = TestUtil.loadToscaServiceModel("/mock/analyzerService/toscasubstitution/",
  89         "/mock/globalServiceTemplates/", null);
  90   }
  91
  92   @Before
  93   public void init() throws IOException {
  94     MockitoAnnotations.initMocks(this);
  95   }
  96
  97   @Test
  98   public void testGetRequirements() throws Exception {
  99     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 100     try (InputStream yamlFile = toscaExtensionYamlUtil
 101         .loadYamlFileIs("/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 102
 103       ServiceTemplate
 104               serviceTemplateFromYaml =
 105               toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 106
 107       NodeTemplate port_0 =
 108               serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui_port_0");
 109       List<RequirementAssignment> reqList =
 110               toscaAnalyzerService.getRequirements(port_0, ToscaConstants.BINDING_REQUIREMENT_ID);
 111       assertEquals(1, reqList.size());
 112
 113       reqList.clear();
 114       NodeTemplate port_1 =
 115               serviceTemplateFromYaml.getTopology_template().getNode_templates().get("cmaui1_port_1");
 116       reqList = toscaAnalyzerService.getRequirements(port_1, ToscaConstants.LINK_REQUIREMENT_ID);
 117       assertEquals(2, reqList.size());
 118
 119       reqList.clear();
 120       reqList = toscaAnalyzerService.getRequirements(port_0, ToscaConstants.LINK_REQUIREMENT_ID);
 121       assertEquals(0, reqList.size());
 122     }
 123   }
 124
 125   @Test
 126   public void testGetNodeTemplateById() throws Exception {
 127     ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
 128     Optional<NodeTemplate> nodeTemplate =
 129         toscaAnalyzerService.getNodeTemplateById(emptyServiceTemplate, "test_net222");
 130     assertEquals(false, nodeTemplate.isPresent());
 131
 132     ServiceTemplate mainServiceTemplate = toscaServiceModel.getServiceTemplates()
 133         .get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 134     nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
 135     assertEquals(true, nodeTemplate.isPresent());
 136
 137     nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net222");
 138     assertEquals(false, nodeTemplate.isPresent());
 139   }
 140
 141   @Test
 142   public void testGetSubstituteServiceTemplateName() throws Exception {
 143     thrown.expect(CoreException.class);
 144     thrown.expectMessage(
 145         "Invalid Substitute Node Template invalid2, mandatory map property service_template_filter with mandatory key substitute_service_template must be defined.");
 146
 147     Optional<String> substituteServiceTemplateName;
 148
 149     ServiceTemplate mainServiceTemplate = toscaServiceModel.getServiceTemplates()
 150         .get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 151     Optional<NodeTemplate> notSubstitutableNodeTemplate =
 152         toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
 153     assertEquals(true, notSubstitutableNodeTemplate.isPresent());
 154
 155     if (notSubstitutableNodeTemplate.isPresent()) {
 156       substituteServiceTemplateName = toscaAnalyzerService
 157           .getSubstituteServiceTemplateName("test_net", notSubstitutableNodeTemplate.get());
 158       assertEquals(false, substituteServiceTemplateName.isPresent());
 159     }
 160
 161     Optional<NodeTemplate> substitutableNodeTemplate =
 162         toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_nested");
 163     assertEquals(true, substitutableNodeTemplate.isPresent());
 164     if (substitutableNodeTemplate.isPresent()) {
 165       substituteServiceTemplateName = toscaAnalyzerService
 166           .getSubstituteServiceTemplateName("test_nested", substitutableNodeTemplate.get());
 167       assertEquals(true, substituteServiceTemplateName.isPresent());
 168       assertEquals("nestedServiceTemplate.yaml", substituteServiceTemplateName.get());
 169     }
 170
 171     NodeTemplate invalidSubstitutableNodeTemplate1 = new NodeTemplate();
 172     substituteServiceTemplateName = toscaAnalyzerService
 173         .getSubstituteServiceTemplateName("invalid1", invalidSubstitutableNodeTemplate1);
 174     assertEquals(false, substituteServiceTemplateName.isPresent());
 175
 176     substitutableNodeTemplate.ifPresent(nodeTemplate -> {
 177       Object serviceTemplateFilter = nodeTemplate.getProperties()
 178               .get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
 179       ((Map) serviceTemplateFilter).clear();
 180       toscaAnalyzerService
 181               .getSubstituteServiceTemplateName("invalid2", nodeTemplate);
 182
 183     });
 184   }
 185
 186
 187   @Test
 188   public void testGetSubstitutableNodeTemplates() throws Exception {
 189     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 190     try (InputStream yamlFile = toscaExtensionYamlUtil
 191         .loadYamlFileIs("/mock/analyzerService/ServiceTemplateSubstituteTest.yaml")) {
 192       ServiceTemplate serviceTemplateFromYaml =
 193               toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 194
 195       Map<String, NodeTemplate> substitutableNodeTemplates =
 196               toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplateFromYaml);
 197       assertEquals(2, substitutableNodeTemplates.size());
 198       assertNotNull(substitutableNodeTemplates.get("test_nested1"));
 199       assertNotNull(substitutableNodeTemplates.get("test_nested2"));
 200
 201       ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
 202       emptyServiceTemplate.setTopology_template(new TopologyTemplate());
 203       substitutableNodeTemplates =
 204               toscaAnalyzerService.getSubstitutableNodeTemplates(emptyServiceTemplate);
 205       assertEquals(0, substitutableNodeTemplates.size());
 206     }
 207
 208     try (InputStream yamlFile = toscaExtensionYamlUtil
 209               .loadYamlFileIs("/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 210       ServiceTemplate serviceTemplateFromYaml = toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 211       Map<String, NodeTemplate> substitutableNodeTemplates =
 212               toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplateFromYaml);
 213       assertEquals(0, substitutableNodeTemplates.size());
 214     }
 215   }
 216
 217   @Test
 218   public void testGetSubstitutionMappedNodeTemplateByExposedReq() throws Exception {
 219     thrown.expect(CoreException.class);
 220     thrown.expectMessage(
 221         "Invalid Tosca model data, missing 'Node Template' entry for 'Node Template' id cmaui_port_9");
 222     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 223     try (InputStream yamlFile = toscaExtensionYamlUtil
 224         .loadYamlFileIs("/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 225       ServiceTemplate nestedServiceTemplateFromYaml =
 226               toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 227
 228       Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate = toscaAnalyzerService
 229               .getSubstitutionMappedNodeTemplateByExposedReq("NestedServiceTemplateSubstituteTest.yaml",
 230                       nestedServiceTemplateFromYaml, "local_storage_server_cmaui");
 231       assertEquals(true, mappedNodeTemplate.isPresent());
 232       mappedNodeTemplate.ifPresent(stringNodeTemplateEntry -> {
 233         assertEquals("server_cmaui", stringNodeTemplateEntry.getKey());
 234         assertNotNull(stringNodeTemplateEntry.getValue());
 235       });
 236
 237       mappedNodeTemplate = toscaAnalyzerService
 238               .getSubstitutionMappedNodeTemplateByExposedReq("NestedServiceTemplateSubstituteTest.yaml",
 239                       nestedServiceTemplateFromYaml, "link_cmaui_port_invalid");
 240       assertEquals(true, mappedNodeTemplate.isPresent());
 241       mappedNodeTemplate.ifPresent(stringNodeTemplateEntry -> {
 242         assertEquals("server_cmaui", stringNodeTemplateEntry.getKey());
 243         assertNotNull(stringNodeTemplateEntry.getValue());
 244       });
 245
 246       ServiceTemplate mainServiceTemplate = toscaServiceModel.getServiceTemplates()
 247               .get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 248       mappedNodeTemplate = toscaAnalyzerService.getSubstitutionMappedNodeTemplateByExposedReq(
 249               toscaServiceModel.getEntryDefinitionServiceTemplate(), mainServiceTemplate,
 250               "local_storage_server_cmaui");
 251       assertEquals(false, mappedNodeTemplate.isPresent());
 252     }
 253   }
 254
 255   @Test
 256   public void invalidSubstitutableMapping() throws Exception {
 257     thrown.expect(CoreException.class);
 258     thrown.expectMessage(
 259         "Invalid Substitution Service Template invalidMappingServiceTemplate.yaml, missing mandatory file 'Node type' in substitution mapping.");
 260     ServiceTemplate invalidMappingServiceTemplate = new ServiceTemplate();
 261     invalidMappingServiceTemplate.setTopology_template(new TopologyTemplate());
 262     invalidMappingServiceTemplate.getTopology_template()
 263         .setSubstitution_mappings(new SubstitutionMapping());
 264     toscaAnalyzerService
 265         .getSubstitutionMappedNodeTemplateByExposedReq("invalidMappingServiceTemplate.yaml",
 266             invalidMappingServiceTemplate, "local_storage_server_cmaui");
 267   }
 268
 269   @Test
 270   public void substitutableMappingWithNoReqMap() throws Exception {
 271     ServiceTemplate mainServiceTemplate = toscaServiceModel.getServiceTemplates()
 272         .get(toscaServiceModel.getEntryDefinitionServiceTemplate());
 273     ServiceTemplate emptyReqMapping = new ServiceTemplate();
 274     emptyReqMapping.setTopology_template(new TopologyTemplate());
 275     emptyReqMapping.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
 276     emptyReqMapping.getTopology_template().getSubstitution_mappings().setNode_type("temp");
 277     Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate = toscaAnalyzerService
 278         .getSubstitutionMappedNodeTemplateByExposedReq(
 279             toscaServiceModel.getEntryDefinitionServiceTemplate(), mainServiceTemplate,
 280             "local_storage_server_cmaui");
 281     assertEquals(false, mappedNodeTemplate.isPresent());
 282   }
 283
 284   @Test
 285   public void testGetSubstitutionMappedNodeTemplateByExposedReqInvalid() throws Exception {
 286     thrown.expect(CoreException.class);
 287     thrown.expectMessage(
 288         "Invalid Tosca model data, missing 'Node Template' entry for 'Node Template' id cmaui_port_9");
 289     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 290     try (InputStream yamlFile = toscaExtensionYamlUtil
 291         .loadYamlFileIs("/mock/analyzerService/NestedServiceTemplateReqTest.yaml")) {
 292       ServiceTemplate nestedServiceTemplateFromYaml =
 293               toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 294
 295       toscaAnalyzerService
 296               .getSubstitutionMappedNodeTemplateByExposedReq("NestedServiceTemplateSubstituteTest.yaml",
 297                       nestedServiceTemplateFromYaml, "link_cmaui_port_invalid");
 298     }
 299   }
 300
 301   @Test
 302   public void testIsDesiredRequirementAssignmentMatch() throws Exception {
 303
 304     RequirementAssignment requirementAssignment = new RequirementAssignment();
 305     String capability = "Test.Capability";
 306     String node = "Test.node";
 307     String relationship = "Test.relationship";
 308     requirementAssignment.setCapability(capability);
 309     requirementAssignment.setNode(node);
 310     requirementAssignment.setRelationship(relationship);
 311
 312     assertEquals(true, toscaAnalyzerService
 313         .isDesiredRequirementAssignment(requirementAssignment, capability, node, relationship));
 314     assertEquals(true, toscaAnalyzerService
 315         .isDesiredRequirementAssignment(requirementAssignment, null, node, relationship));
 316     assertEquals(true, toscaAnalyzerService
 317         .isDesiredRequirementAssignment(requirementAssignment, capability, null, relationship));
 318     assertEquals(true, toscaAnalyzerService
 319         .isDesiredRequirementAssignment(requirementAssignment, capability, node, null));
 320     assertEquals(true, toscaAnalyzerService
 321         .isDesiredRequirementAssignment(requirementAssignment, null, null, relationship));
 322     assertEquals(true, toscaAnalyzerService
 323         .isDesiredRequirementAssignment(requirementAssignment, capability, null, null));
 324     assertEquals(true, toscaAnalyzerService
 325         .isDesiredRequirementAssignment(requirementAssignment, null, node, null));
 326
 327   }
 328
 329   @Test
 330   public void testIsDesiredRequirementAssignmentNoMatch() throws Exception {
 331
 332     RequirementAssignment requirementAssignment = new RequirementAssignment();
 333     String capability = "Test.Capability";
 334     String node = "Test.node";
 335     String relationship = "Test.relationship";
 336     requirementAssignment.setCapability(capability);
 337     requirementAssignment.setNode(node);
 338     requirementAssignment.setRelationship(relationship);
 339
 340     assertEquals(false, toscaAnalyzerService
 341         .isDesiredRequirementAssignment(requirementAssignment, "no", node, relationship));
 342     assertEquals(false, toscaAnalyzerService
 343         .isDesiredRequirementAssignment(requirementAssignment, "no", "no", relationship));
 344     assertEquals(false, toscaAnalyzerService
 345         .isDesiredRequirementAssignment(requirementAssignment, "no", "no", "no"));
 346     assertEquals(false, toscaAnalyzerService
 347         .isDesiredRequirementAssignment(requirementAssignment, capability, "no", relationship));
 348     assertEquals(false, toscaAnalyzerService
 349         .isDesiredRequirementAssignment(requirementAssignment, capability, node, "no"));
 350     assertEquals(false, toscaAnalyzerService
 351         .isDesiredRequirementAssignment(requirementAssignment, capability, "no", "no"));
 352     assertEquals(false, toscaAnalyzerService
 353         .isDesiredRequirementAssignment(requirementAssignment, "no", null, null));
 354     assertEquals(false, toscaAnalyzerService
 355         .isDesiredRequirementAssignment(requirementAssignment, null, null, null));
 356
 357
 358   }
 359
 360   @Test
 361   public void shouldReturnFalseIfNdTmpIsNull() {
 362     assertFalse(toscaAnalyzerService
 363         .isTypeOf(null, ToscaNodeType.NATIVE_NETWORK, new ServiceTemplate(),
 364             toscaServiceModelMock));
 365   }
 366
 367   @Test
 368   public void shouldReturnTrueIfNdTmpTypeIsOfRequestedType() {
 369     NodeTemplate nodeTemplate = new NodeTemplate();
 370     String nodeTypeToSearch = ToscaNodeType.NATIVE_BLOCK_STORAGE;
 371     nodeTemplate.setType(nodeTypeToSearch);
 372     assertTrue(toscaAnalyzerService
 373         .isTypeOf(nodeTemplate, nodeTypeToSearch, new ServiceTemplate(),
 374             toscaServiceModelMock));
 375   }
 376
 377   @Test
 378   public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyAndNdTyDerivedFromRequestedType() {
 379     String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 380     when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 381     Map<String, NodeType> stNodeTypes = new HashMap<>();
 382     addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 383     NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 384     addNodeType(stNodeTypes, typeToMatch, nodeType);
 385     ServiceTemplate serviceTemplate = new ServiceTemplate();
 386     serviceTemplate.setNode_types(stNodeTypes);
 387     assertTrue(toscaAnalyzerService
 388         .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE,
 389             serviceTemplate, toscaServiceModelMock));
 390
 391   }
 392
 393   @Test
 394   public void shouldThrowCoreExceptionForInvalidNodeType() {
 395     thrown.expect(CoreException.class);
 396     thrown.expectMessage(
 397         "NodeType 'AAA' or one of its derivedFrom node type hierarchy, is not defined in tosca service model");
 398     when(nodeTemplateMock.getType()).thenReturn("AAA");
 399     Map<String, NodeType> stNodeTypes = new HashMap<>();
 400     addNodeType(stNodeTypes, "notImportant", new NodeType());
 401     ServiceTemplate serviceTemplate = new ServiceTemplate();
 402     serviceTemplate.setNode_types(stNodeTypes);
 403     toscaAnalyzerService
 404         .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_COMPUTE, serviceTemplate,
 405             toscaServiceModelMock);
 406   }
 407
 408   @Test
 409   public void shouldThrowCoreExceptionForInvalidNodeType2Level() {
 410     thrown.expect(CoreException.class);
 411     thrown.expectMessage(
 412         "NodeType 'A' or one of its derivedFrom node type hierarchy, is not defined in tosca service model");
 413     String typeToMatch = "A";
 414     when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 415     Map<String, NodeType> stNodeTypes = new HashMap<>();
 416     addNodeType(stNodeTypes, "notImportant", new NodeType());
 417     addNodeType(stNodeTypes, "A", createNodeType("ADerivedFromB"));
 418     addNodeType(stNodeTypes, "ADerivedFromB'", createNodeType("BDerivedFromC"));
 419     ServiceTemplate serviceTemplate = new ServiceTemplate();
 420     serviceTemplate.setNode_types(stNodeTypes);
 421     assertTrue(toscaAnalyzerService
 422         .isTypeOf(nodeTemplateMock, "BDerivedFromC", serviceTemplate, toscaServiceModelMock));
 423   }
 424
 425   @Test
 426   public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyAndNotDerivedFromRequestedTypeBut2ndLevelDerivedFromMatch() {
 427     String typeToMatch = "A";
 428     when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 429     Map<String, NodeType> stNodeTypes = new HashMap<>();
 430     addNodeType(stNodeTypes, "notImportant", new NodeType());
 431     addNodeType(stNodeTypes, "A", createNodeType("ADerivedFromB"));
 432     addNodeType(stNodeTypes, "ADerivedFromB", createNodeType("BDerivedFromC"));
 433     ServiceTemplate serviceTemplate = new ServiceTemplate();
 434     serviceTemplate.setNode_types(stNodeTypes);
 435     assertTrue(toscaAnalyzerService
 436         .isTypeOf(nodeTemplateMock, "BDerivedFromC", serviceTemplate, toscaServiceModelMock));
 437   }
 438
 439   private NodeType createNodeType(String derivedFrom) {
 440     NodeType nodeType = new NodeType();
 441     nodeType.setDerived_from(derivedFrom);
 442     return nodeType;
 443   }
 444
 445   private void addNodeType(Map<String, NodeType> stNodeTypes, String key, NodeType nodeType) {
 446     stNodeTypes.put(key, nodeType);
 447   }
 448
 449   @Test
 450   public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyButRequestedTypeNotMatchButFoundIn1stLevelImports() {
 451     String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 452     when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 453     ServiceTemplate mainST = new ServiceTemplate();
 454     List<Map<String, Import>> imports = new ArrayList<>();
 455     Map<String, Import> importMap = new HashMap<>();
 456     Import anImport = new Import();
 457     anImport.setFile("mainImport");
 458     importMap.put("bla bla", anImport);
 459     imports.add(importMap);
 460     mainST.setImports(imports);
 461
 462     //create searchable service template
 463     Map<String, NodeType> stNodeTypes = new HashMap<>();
 464     addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 465     NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 466     addNodeType(stNodeTypes, typeToMatch, nodeType);
 467     ServiceTemplate serviceTemplate = new ServiceTemplate();
 468     serviceTemplate.setNode_types(stNodeTypes);
 469
 470     // add service templates to tosca service model
 471     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModelMock.getServiceTemplates();
 472     serviceTemplates.put("testMainServiceTemplate", mainST);
 473     serviceTemplates.put("mainImport", serviceTemplate);
 474     when(toscaServiceModelMock.getServiceTemplates()).thenReturn(serviceTemplates);
 475
 476     assertTrue(toscaAnalyzerService
 477         .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainST,
 478             toscaServiceModelMock));
 479   }
 480
 481   @Test
 482   public void shouldReturnTrueIfNdTmpTypeIsFoundInSrvTmpNdTyButRequestedTypeNotMatchButFoundIn2ndLevelImports() {
 483     String typeToMatch = ToscaNodeType.CINDER_VOLUME;
 484     when(nodeTemplateMock.getType()).thenReturn(typeToMatch);
 485     ServiceTemplate mainST = new ServiceTemplate();
 486     List<Map<String, Import>> imports = new ArrayList<>();
 487     Map<String, Import> importMap = new HashMap<>();
 488     Import anImport = new Import();
 489     anImport.setFile("refToMainImport");
 490     importMap.put("bla bla", anImport);
 491     imports.add(importMap);
 492     mainST.setImports(imports);
 493
 494     //create searchable service template
 495     Map<String, NodeType> stNodeTypes = new HashMap<>();
 496     addNodeType(stNodeTypes, ToscaNodeType.NATIVE_COMPUTE, new NodeType());
 497     NodeType nodeType = createNodeType(ToscaNodeType.NATIVE_BLOCK_STORAGE);
 498     addNodeType(stNodeTypes, typeToMatch, nodeType);
 499     ServiceTemplate serviceTemplate = new ServiceTemplate();
 500     serviceTemplate.setNode_types(stNodeTypes);
 501
 502     // create 1st level service template with import only
 503     ServiceTemplate firstLevelST = new ServiceTemplate();
 504     List<Map<String, Import>> firstLevelImports = new ArrayList<>();
 505     Map<String, Import> firstLevelImportsMap = new HashMap<>();
 506     Import firstLevelImport = new Import();
 507     firstLevelImport.setFile("mainImport");
 508     firstLevelImportsMap.put("bla bla 2", firstLevelImport);
 509     firstLevelImports.add(firstLevelImportsMap);
 510     firstLevelST.setImports(firstLevelImports);
 511
 512     // add service templates to tosca service model
 513     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModelMock.getServiceTemplates();
 514     serviceTemplates.put("testMainServiceTemplate", mainST);
 515     serviceTemplates.put("refToMainImport", firstLevelST);
 516     serviceTemplates.put("mainImport", serviceTemplate);
 517     when(toscaServiceModelMock.getServiceTemplates()).thenReturn(serviceTemplates);
 518
 519     assertTrue(toscaAnalyzerService
 520         .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainST,
 521             toscaServiceModelMock));
 522   }
 523
 524   // not found at all should throw core exception
 525
 526
 527 }