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

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