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