2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.tosca.services.impl;
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;
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;
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;
59 import java.util.Optional;
64 * @since July 14, 2016
66 @RunWith(MockitoJUnitRunner.class)
67 public class ToscaAnalyzerServiceImplTest {
70 SrvTmp: ServiceTemplate
75 private static ToscaAnalyzerService toscaAnalyzerService;
76 private static ToscaServiceModel toscaServiceModel;
78 public ExpectedException thrown = ExpectedException.none();
81 NodeTemplate nodeTemplateMock;
83 ToscaServiceModel toscaServiceModelMock;
86 public static void onlyOnceSetUp() throws IOException {
87 toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
88 toscaServiceModel = TestUtil.loadToscaServiceModel("/mock/analyzerService/toscasubstitution/",
89 "/mock/globalServiceTemplates/", null);
93 public void init() throws IOException {
94 MockitoAnnotations.initMocks(this);
98 public void testGetRequirements() throws Exception {
99 ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
100 InputStream yamlFile = toscaExtensionYamlUtil
101 .loadYamlFileIs("/mock/analyzerService/NestedServiceTemplateReqTest.yaml");
103 serviceTemplateFromYaml =
104 toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
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());
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());
119 reqList = toscaAnalyzerService.getRequirements(port_0, ToscaConstants.LINK_REQUIREMENT_ID);
120 assertEquals(0, reqList.size());
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());
130 ServiceTemplate mainServiceTemplate = toscaServiceModel.getServiceTemplates()
131 .get(toscaServiceModel.getEntryDefinitionServiceTemplate());
132 nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
133 assertEquals(true, nodeTemplate.isPresent());
135 nodeTemplate = toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net222");
136 assertEquals(false, nodeTemplate.isPresent());
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.");
145 Optional<String> substituteServiceTemplateName;
147 ServiceTemplate mainServiceTemplate = toscaServiceModel.getServiceTemplates()
148 .get(toscaServiceModel.getEntryDefinitionServiceTemplate());
149 Optional<NodeTemplate> notSubstitutableNodeTemplate =
150 toscaAnalyzerService.getNodeTemplateById(mainServiceTemplate, "test_net");
151 assertEquals(true, notSubstitutableNodeTemplate.isPresent());
153 if (notSubstitutableNodeTemplate.isPresent()) {
154 substituteServiceTemplateName = toscaAnalyzerService
155 .getSubstituteServiceTemplateName("test_net", notSubstitutableNodeTemplate.get());
156 assertEquals(false, substituteServiceTemplateName.isPresent());
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());
169 NodeTemplate invalidSubstitutableNodeTemplate1 = new NodeTemplate();
170 substituteServiceTemplateName = toscaAnalyzerService
171 .getSubstituteServiceTemplateName("invalid1", invalidSubstitutableNodeTemplate1);
172 assertEquals(false, substituteServiceTemplateName.isPresent());
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();
180 .getSubstituteServiceTemplateName("invalid2", invalidSubstitutableNodeTemplate2);
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);
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"));
200 ServiceTemplate emptyServiceTemplate = new ServiceTemplate();
201 emptyServiceTemplate.setTopology_template(new TopologyTemplate());
202 substitutableNodeTemplates =
203 toscaAnalyzerService.getSubstitutableNodeTemplates(emptyServiceTemplate);
204 assertEquals(0, substitutableNodeTemplates.size());
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());
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);
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());
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());
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());
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());
261 .getSubstitutionMappedNodeTemplateByExposedReq("invalidMappingServiceTemplate.yaml",
262 invalidMappingServiceTemplate, "local_storage_server_cmaui");
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());
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);
292 .getSubstitutionMappedNodeTemplateByExposedReq("NestedServiceTemplateSubstituteTest.yaml",
293 nestedServiceTemplateFromYaml, "link_cmaui_port_invalid");
297 public void testIsDesiredRequirementAssignmentMatch() throws Exception {
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);
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));
325 public void testIsDesiredRequirementAssignmentNoMatch() throws Exception {
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);
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));
356 public void shouldReturnFalseIfNdTmpIsNull() {
357 assertFalse(toscaAnalyzerService
358 .isTypeOf(null, ToscaNodeType.NATIVE_NETWORK, new ServiceTemplate(),
359 toscaServiceModelMock));
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));
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));
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);
399 .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_COMPUTE, serviceTemplate,
400 toscaServiceModelMock);
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));
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));
434 private NodeType createNodeType(String derivedFrom) {
435 NodeType nodeType = new NodeType();
436 nodeType.setDerived_from(derivedFrom);
440 private void addNodeType(Map<String, NodeType> stNodeTypes, String key, NodeType nodeType) {
441 stNodeTypes.put(key, nodeType);
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);
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);
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);
471 assertTrue(toscaAnalyzerService
472 .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainST,
473 toscaServiceModelMock));
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);
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);
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);
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);
514 assertTrue(toscaAnalyzerService
515 .isTypeOf(nodeTemplateMock, ToscaNodeType.NATIVE_BLOCK_STORAGE, mainST,
516 toscaServiceModelMock));
519 // not found at all should throw core exception