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=========================================================
19 * Modifications copyright (c) 2019 Nokia
20 * ================================================================================
23 package org.openecomp.sdc.be.components;
25 import static org.junit.jupiter.api.Assertions.assertEquals;
26 import static org.junit.jupiter.api.Assertions.assertFalse;
27 import static org.junit.jupiter.api.Assertions.assertNotNull;
28 import static org.junit.jupiter.api.Assertions.assertNull;
29 import static org.junit.jupiter.api.Assertions.assertSame;
30 import static org.junit.jupiter.api.Assertions.assertThrows;
31 import static org.junit.jupiter.api.Assertions.assertTrue;
32 import static org.junit.jupiter.api.Assertions.fail;
33 import static org.mockito.ArgumentMatchers.any;
34 import static org.mockito.ArgumentMatchers.anyMap;
35 import static org.mockito.ArgumentMatchers.anyString;
36 import static org.mockito.ArgumentMatchers.contains;
37 import static org.mockito.ArgumentMatchers.eq;
38 import static org.mockito.ArgumentMatchers.isNull;
39 import static org.mockito.Mockito.anyBoolean;
40 import static org.mockito.Mockito.mock;
41 import static org.mockito.Mockito.times;
42 import static org.mockito.Mockito.verify;
43 import static org.mockito.Mockito.when;
45 import fj.data.Either;
47 import java.io.IOException;
48 import java.net.URISyntaxException;
49 import java.util.ArrayList;
50 import java.util.Arrays;
51 import java.util.Collections;
52 import java.util.HashMap;
53 import java.util.List;
55 import java.util.Optional;
57 import org.apache.commons.collections4.CollectionUtils;
58 import org.apache.commons.collections4.MapUtils;
59 import org.apache.commons.lang3.tuple.ImmutablePair;
60 import org.junit.jupiter.api.BeforeAll;
61 import org.junit.jupiter.api.BeforeEach;
62 import org.junit.jupiter.api.Test;
63 import org.mockito.stubbing.Answer;
64 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
65 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
66 import org.openecomp.sdc.be.components.impl.ImportUtils;
67 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
68 import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
69 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
70 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
71 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
72 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
73 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
74 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
75 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
76 import org.openecomp.sdc.be.config.Configuration;
77 import org.openecomp.sdc.be.config.ConfigurationManager;
78 import org.openecomp.sdc.be.dao.api.ActionStatus;
79 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
80 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
81 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
82 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
83 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
84 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
85 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
86 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
87 import org.openecomp.sdc.be.impl.ComponentsUtils;
88 import org.openecomp.sdc.be.model.CapabilityDefinition;
89 import org.openecomp.sdc.be.model.Component;
90 import org.openecomp.sdc.be.model.InterfaceDefinition;
91 import org.openecomp.sdc.be.model.NodeTypeDefinition;
92 import org.openecomp.sdc.be.model.NodeTypeMetadata;
93 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
94 import org.openecomp.sdc.be.model.PropertyConstraint;
95 import org.openecomp.sdc.be.model.PropertyDefinition;
96 import org.openecomp.sdc.be.model.RequirementDefinition;
97 import org.openecomp.sdc.be.model.Resource;
98 import org.openecomp.sdc.be.model.UploadResourceInfo;
99 import org.openecomp.sdc.be.model.User;
100 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
101 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
102 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
103 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
104 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
105 import org.openecomp.sdc.be.user.UserBusinessLogic;
106 import org.openecomp.sdc.be.utils.TypeUtils;
107 import org.openecomp.sdc.common.api.ConfigurationSource;
108 import org.openecomp.sdc.common.impl.ExternalConfiguration;
109 import org.openecomp.sdc.common.impl.FSConfigurationSource;
110 import org.openecomp.sdc.common.zip.ZipUtils;
111 import org.openecomp.sdc.common.zip.exception.ZipException;
112 import org.openecomp.sdc.exception.PolicyException;
113 import org.openecomp.sdc.exception.ResponseFormat;
115 class ResourceImportManagerTest {
117 private ResourceImportManager importManager;
119 private final AuditingManager auditingManager = mock(AuditingManager.class);
120 private final ResponseFormatManager responseFormatManager = mock(ResponseFormatManager.class);
121 private final ResourceBusinessLogic resourceBusinessLogic = mock(ResourceBusinessLogic.class);
122 private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = mock(InterfaceOperationBusinessLogic.class);
123 private final InterfaceDefinitionHandler interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
124 private final JanusGraphDao janusGraphDao = mock(JanusGraphDao.class);
125 private final UserBusinessLogic userAdmin = mock(UserBusinessLogic.class);
126 private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
127 private final ComponentsUtils componentsUtils = mock(ComponentsUtils.class);
128 private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
129 private UploadResourceInfo resourceMD;
133 public static void beforeClass() {
134 String appConfigDir = "src/test/resources/config/catalog-be";
135 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
136 final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
138 Configuration configuration = new Configuration();
139 configuration.setJanusGraphInMemoryGraph(true);
140 configurationManager.setConfiguration(configuration);
144 public void beforeTest() {
145 importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler, janusGraphDao);
146 importManager.setAuditingManager(auditingManager);
147 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any())).thenReturn(Either.left(null));
148 when(toscaOperationFacade.getLatestByToscaResourceNameAndModel(anyString(), any())).thenReturn(Either.left(null));
149 importManager.setResponseFormatManager(responseFormatManager);
150 importManager.setResourceBusinessLogic(resourceBusinessLogic);
151 importManager.setToscaOperationFacade(toscaOperationFacade);
152 Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
153 when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
154 any(JsonParseFlagEnum.class), any())).thenReturn(notFound);
155 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
156 .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
157 resourceMD = createDummyResourceMD();
162 void testBasicResourceCreation() throws IOException {
163 user.setUserId(resourceMD.getContactId());
164 user.setRole("ADMIN");
165 user.setFirstName("Jhon");
166 user.setLastName("Doh");
167 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
169 setResourceBusinessLogicMock();
171 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
173 ImmutablePair<Resource, ActionStatus> createResource =
174 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
175 Resource resource = createResource.left;
177 testSetConstantMetaData(resource);
178 testSetMetaDataFromJson(resource, resourceMD);
180 testSetDerivedFrom(resource);
181 testSetProperties(resource);
183 verify(resourceBusinessLogic).propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true),
188 void testReimportVfcToExistedResource() throws IOException {
189 user.setUserId(resourceMD.getContactId());
190 user.setRole("ADMIN");
191 user.setFirstName("John");
192 user.setLastName("Doe");
193 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
195 setResourceBusinessLogicMock();
197 final String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
199 ImmutablePair<Resource, ActionStatus> createResource =
200 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
201 assertNotNull(createResource);
202 Resource resource = createResource.left;
203 assertNotNull(resource);
205 final GraphVertex graphVertex_1 = new GraphVertex();
206 graphVertex_1.setUniqueId("1-2-3-4-5-6-7");
207 graphVertex_1.addMetadataProperty(GraphPropertyEnum.VERSION, "1.1");
208 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
209 .thenReturn(Either.left(Arrays.asList(graphVertex_1)));
210 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
211 createResource = reimportVfc(resource, jsonContent);
212 assertNotNull(createResource);
213 resource = createResource.left;
214 assertNotNull(resource);
215 testPropertiesAfterReimport(resource);
217 final GraphVertex graphVertex_2 = new GraphVertex();
218 graphVertex_2.setUniqueId("11-22-33-44-55-66-77");
219 graphVertex_2.addMetadataProperty(GraphPropertyEnum.VERSION, "2.2");
220 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
221 .thenReturn(Either.left(Arrays.asList(graphVertex_1, graphVertex_2)));
222 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
223 createResource = reimportVfc(resource, jsonContent);
224 assertNotNull(createResource);
225 resource = createResource.left;
226 assertNotNull(resource);
227 testPropertiesAfterReimport(resource);
229 verify(resourceBusinessLogic, times(3))
230 .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
234 void importAllNormativeResourceSuccessTest() {
235 final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
236 var nodeTypeMetadata1 = new NodeTypeMetadata();
237 nodeTypeMetadata1.setToscaName("my.tosca.Type");
238 nodeTypeMetadata1.setName("Type");
239 nodeMetadataList.add(nodeTypeMetadata1);
240 var nodeTypeMetadata2 = new NodeTypeMetadata();
241 nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
242 nodeMetadataList.add(nodeTypeMetadata2);
243 var nodeTypesMetadataList = new NodeTypesMetadataList();
244 nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
245 var yaml = "node_types:\n"
246 + " my.tosca.Type:\n"
247 + " description: a description";
249 when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null));
250 when(resourceBusinessLogic
251 .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
252 .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
254 importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false);
255 verify(janusGraphDao).commit();
259 void importAllNormativeResourceTest_invalidYaml() {
260 var invalidYaml = "node_types: my.tosca.Type:";
262 final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
263 () -> importManager.importAllNormativeResource(invalidYaml, new NodeTypesMetadataList(), new User(), false, false));
264 assertEquals(ActionStatus.INVALID_NODE_TYPES_YAML, actualException.getActionStatus());
268 void importAllNormativeResourceTest_exceptionDuringImportShouldTriggerRollback() {
269 when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(mock(ResponseFormat.class));
270 when(toscaOperationFacade.getLatestByName(any(), any())).thenThrow(new RuntimeException());
272 final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
273 var nodeTypeMetadata1 = new NodeTypeMetadata();
274 nodeTypeMetadata1.setToscaName("my.tosca.Type");
275 nodeMetadataList.add(nodeTypeMetadata1);
276 var nodeTypeMetadata2 = new NodeTypeMetadata();
277 nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
278 nodeMetadataList.add(nodeTypeMetadata2);
279 var nodeTypesMetadataList = new NodeTypesMetadataList();
280 nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
281 var yaml = "node_types:\n"
282 + " my.tosca.Type:\n"
283 + " description: a description";
285 assertThrows(ComponentException.class,
286 () -> importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false));
287 verify(janusGraphDao).rollback();
291 void testResourceCreationFailed() {
292 user.setUserId(resourceMD.getContactId());
293 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
294 ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
296 when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
297 setResourceBusinessLogicMock();
299 String jsonContent = "this is an invalid yml!";
300 ComponentException errorInfoFromTest = null;
302 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
303 } catch (ComponentException e) {
304 errorInfoFromTest = e;
306 assertNotNull(errorInfoFromTest);
307 assertEquals(ActionStatus.GENERAL_ERROR, errorInfoFromTest.getActionStatus());
309 verify(resourceBusinessLogic, times(0))
310 .createOrUpdateResourceByImport(any(Resource.class), eq(user), eq(true), eq(false), eq(true), eq(null), eq(null), eq(false));
311 verify(resourceBusinessLogic, times(0))
312 .propagateStateToCertified(eq(user), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
316 void testResourceCreationWithCapabilities() throws IOException {
317 user.setUserId(resourceMD.getContactId());
318 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
320 setResourceBusinessLogicMock();
322 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
324 ImmutablePair<Resource, ActionStatus> createResource =
325 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
326 Resource resource = createResource.left;
327 testSetCapabilities(resource);
329 verify(resourceBusinessLogic)
330 .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
331 verify(resourceBusinessLogic).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
336 void testResourceCreationWithRequirements() throws IOException {
337 user.setUserId(resourceMD.getContactId());
338 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
340 setResourceBusinessLogicMock();
342 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
344 ImmutablePair<Resource, ActionStatus> createResource =
345 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
346 testSetRequirements(createResource.left);
351 void testResourceCreationWithInterfaceImplementation() throws IOException {
352 user.setUserId(resourceMD.getContactId());
353 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
355 setResourceBusinessLogicMock();
357 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
359 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
360 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
361 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
362 Map<String, OperationDataDefinition> operations = new HashMap<>();
363 operations.put("configure", new OperationDataDefinition());
364 interfaceDefinition.setOperations(operations);
365 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
366 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
368 final ImmutablePair<Resource, ActionStatus> createResource =
369 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
370 assertSetInterfaceImplementation(createResource.left);
374 void testReimportVfcWithInterfaceImplementation() throws IOException {
375 user.setUserId(resourceMD.getContactId());
376 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
378 setResourceBusinessLogicMock();
380 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
382 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
383 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
384 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
385 Map<String, OperationDataDefinition> operations = new HashMap<>();
386 operations.put("configure", new OperationDataDefinition());
387 interfaceDefinition.setOperations(operations);
388 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
389 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
391 ImmutablePair<Resource, ActionStatus> createResource =
392 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
393 assertNotNull(createResource);
394 Resource resource = createResource.getLeft();
395 assertNotNull(resource);
396 assertSetInterfaceImplementation(resource);
398 final GraphVertex graphVertex = new GraphVertex();
399 graphVertex.setUniqueId("1-2-3-4-5-6-7");
400 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
401 .thenReturn(Either.left(Arrays.asList(graphVertex)));
402 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
403 createResource = reimportVfc(resource, jsonContent);
404 assertNotNull(createResource);
405 resource = createResource.getLeft();
406 assertNotNull(resource);
407 assertSetInterfaceImplementationAfterReimport(resource);
411 void testResourceCreationWithInterfaceImplementation_UnknownInterface() throws IOException {
412 user.setUserId(resourceMD.getContactId());
413 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
415 setResourceBusinessLogicMock();
417 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-unknown-interface-impl.yml");
419 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
420 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
421 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
422 Map<String, OperationDataDefinition> operations = new HashMap<>();
423 operations.put("configure", new OperationDataDefinition());
424 interfaceDefinition.setOperations(operations);
425 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
426 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
428 ImmutablePair<Resource, ActionStatus> createResource =
429 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
430 assertNull(createResource.left.getInterfaces());
434 void testResourceCreationWitInterfaceImplementation_UnknownOperation() throws IOException {
435 user.setUserId(resourceMD.getContactId());
436 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
438 setResourceBusinessLogicMock();
440 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl-unknown-operation.yml");
442 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
443 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
444 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
445 Map<String, OperationDataDefinition> operations = new HashMap<>();
446 operations.put("configure", new OperationDataDefinition());
447 interfaceDefinition.setOperations(operations);
448 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
449 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
451 ImmutablePair<Resource, ActionStatus> createResource =
452 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
453 assertNull(createResource.left.getInterfaces());
457 void testResourceCreationFailedVendorReleaseAlreadyExists() throws IOException {
458 user.setUserId(resourceMD.getContactId());
459 user.setRole("ADMIN");
460 user.setFirstName("Jhon");
461 user.setLastName("Doh");
462 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
464 setResourceBusinessLogicMock();
465 final Either<Component, StorageOperationStatus> foundResourceEither = Either.left(mock(Resource.class));
466 when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
467 any(JsonParseFlagEnum.class), any())).thenReturn(foundResourceEither);
468 when(toscaOperationFacade.isNodeAssociatedToModel(eq(null), any(Resource.class))).thenReturn(true);
470 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
472 var actualException = assertThrows(ByActionStatusComponentException.class,
473 () -> importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false));
474 assertEquals(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, actualException.getActionStatus());
478 void getAllResourcesYamlAndNodeTypesMetadataListTest() {
479 NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
480 List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
481 Map<String, Object> allTypesToCreate = new HashMap<>();
482 ServiceCsarInfo csarInfo= getCsarInfo();
483 List<NodeTypeDefinition> nodeTypesToCreate = csarInfo.getNodeTypesUsed();
484 nodeTypesToCreate.stream().forEach(nodeType -> {
485 allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
486 nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
488 nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
490 when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null)).thenReturn(Either.left(null));
491 when(toscaOperationFacade.getLatestByToscaResourceName("org.openecomp.resource.VFC-root", "ETSI SOL001 v2.5.1"))
492 .thenReturn(Either.left(null));
493 when(resourceBusinessLogic
494 .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
495 .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK)).thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
497 importManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, user, "", false, false);
498 verify(janusGraphDao).commit();
501 private void setResourceBusinessLogicMock() {
502 when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
503 when(resourceBusinessLogic.createOrUpdateResourceByImport(any(Resource.class), any(User.class), anyBoolean(), anyBoolean(), anyBoolean(),
504 eq(null), eq(null), eq(false)))
505 .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
506 Object[] args = invocation.getArguments();
507 return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
511 resourceBusinessLogic.propagateStateToCertified(any(User.class), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false),
512 eq(true), eq(false)))
513 .thenAnswer((Answer<Resource>) invocation -> {
514 Object[] args = invocation.getArguments();
515 return (Resource) args[1];
518 when(resourceBusinessLogic.createResourceByDao(
519 any(Resource.class), any(User.class), any(AuditingActionEnum.class), anyBoolean(), anyBoolean())).thenAnswer(
520 (Answer<Either<Resource, ResponseFormat>>) invocation -> {
521 Object[] args = invocation.getArguments();
522 return Either.left((Resource) args[0]);
525 when(resourceBusinessLogic.validateResourceBeforeCreate(
526 any(Resource.class), any(User.class), any(AuditingActionEnum.class), eq(false), eq(null))).thenAnswer(
527 (Answer<Either<Resource, ResponseFormat>>) invocation -> {
528 Object[] args = invocation.getArguments();
529 return Either.left((Resource) args[0]);
533 when(resourceBusinessLogic.validatePropertiesDefaultValues(any(Resource.class))).thenReturn(true);
536 private ResponseFormat createGeneralErrorInfo() {
537 ResponseFormat responseFormat = new ResponseFormat(500);
538 responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
539 return responseFormat;
542 private UploadResourceInfo createDummyResourceMD() {
543 UploadResourceInfo resourceMD = new UploadResourceInfo();
544 resourceMD.setName("tosca.nodes.BlockStorage");
545 resourceMD.setPayloadName("payLoad");
546 resourceMD.addSubCategory("Generic", "Infrastructure");
547 resourceMD.setContactId("ya107f");
548 resourceMD.setResourceIconPath("defaulticon");
549 resourceMD.setTags(Collections.singletonList("BlockStorage"));
550 resourceMD.setDescription(
551 "Represents a server-local block storage device (i.e., not shared) offering evenly sized blocks of data from which raw storage volumes can be created.");
552 resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
553 resourceMD.setNormative(true);
557 private void testSetProperties(Resource resource) {
558 List<PropertyDefinition> propertiesList = resource.getProperties();
560 Map<String, PropertyDefinition> properties = new HashMap<>();
561 for (PropertyDefinition propertyDefinition : propertiesList) {
562 properties.put(propertyDefinition.getName(), propertyDefinition);
565 assertEquals(3, properties.size());
566 assertTrue(properties.containsKey("size"));
567 PropertyDefinition propertyDefinition = properties.get("size");
568 assertEquals("scalar-unit.size", propertyDefinition.getType());
569 assertEquals(1, propertyDefinition.getConstraints().size());
570 PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
571 assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
573 assertTrue(properties.containsKey("volume_id"));
574 propertyDefinition = properties.get("volume_id");
575 assertEquals("string", propertyDefinition.getType());
576 assertFalse(propertyDefinition.isRequired());
578 assertTrue(properties.containsKey("snapshot_id"));
579 propertyDefinition = properties.get("snapshot_id");
580 assertEquals("string", propertyDefinition.getType());
581 assertFalse(propertyDefinition.isRequired());
585 private ImmutablePair<Resource, ActionStatus> reimportVfc(final Resource resource, final String jsonContent) {
586 List<PropertyDefinition> propertiesList = resource.getProperties();
587 if (CollectionUtils.isEmpty(propertiesList)) {
588 propertiesList = new ArrayList<>();
590 final PropertyDefinition propertyDefinition = new PropertyDefinition();
591 propertyDefinition.setName("oneMore");
592 propertyDefinition.setUserCreated(true);
593 propertyDefinition.setType("boolean");
594 propertiesList.add(propertyDefinition);
595 resource.setProperties(propertiesList);
597 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
598 if (MapUtils.isEmpty(interfaces)) {
599 interfaces = new HashMap<>();
601 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
602 interfaceDefinition.setType("tosca.interfaces.relationship.Configure");
603 interfaceDefinition.setUserCreated(true);
604 final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
605 operationDataDefinition.setName("add_source");
606 final Map<String, OperationDataDefinition> operationDataDefinitionMap = new HashMap<>();
607 operationDataDefinitionMap.put(operationDataDefinition.getName(), operationDataDefinition);
608 interfaceDefinition.setOperations(operationDataDefinitionMap);
609 interfaces.put(interfaceDefinition.getType(), interfaceDefinition);
610 resource.setInterfaces(interfaces);
612 return importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
616 private void testPropertiesAfterReimport(Resource resource) {
617 List<PropertyDefinition> propertiesList = resource.getProperties();
619 Map<String, PropertyDefinition> properties = new HashMap<>();
620 for (PropertyDefinition propertyDefinition : propertiesList) {
621 properties.put(propertyDefinition.getName(), propertyDefinition);
624 assertEquals(4, properties.size());
626 assertTrue(properties.containsKey("size"));
627 PropertyDefinition propertyDefinition = properties.get("size");
628 assertEquals("scalar-unit.size", propertyDefinition.getType());
629 assertEquals(1, propertyDefinition.getConstraints().size());
630 PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
631 assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
633 assertTrue(properties.containsKey("volume_id"));
634 propertyDefinition = properties.get("volume_id");
635 assertEquals("string", propertyDefinition.getType());
636 assertFalse(propertyDefinition.isRequired());
637 assertFalse(propertyDefinition.isUserCreated());
639 assertTrue(properties.containsKey("snapshot_id"));
640 propertyDefinition = properties.get("snapshot_id");
641 assertEquals("string", propertyDefinition.getType());
642 assertFalse(propertyDefinition.isRequired());
643 assertFalse(propertyDefinition.isUserCreated());
645 assertTrue(properties.containsKey("oneMore"));
646 propertyDefinition = properties.get("oneMore");
647 assertEquals("boolean", propertyDefinition.getType());
648 assertFalse(propertyDefinition.isRequired());
649 assertTrue(propertyDefinition.isUserCreated());
652 private void testSetCapabilities(Resource resource) {
653 Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
654 assertEquals(3, capabilities.size());
655 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
656 List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
657 CapabilityDefinition capability = capabilityList.get(0);
658 assertEquals("tosca.capabilities.Endpoint", capability.getType());
659 assertEquals("data_endpoint", capability.getName());
661 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
662 capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
663 capability = capabilityList.get(0);
664 assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
665 assertEquals("admin_endpoint", capability.getName());
667 assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
668 capabilityList = capabilities.get("tosca.capabilities.Container");
669 capability = capabilityList.get(0);
670 assertEquals("tosca.capabilities.Container", capability.getType());
671 assertEquals("host", capability.getName());
673 List<String> validSourceTypes = capability.getValidSourceTypes();
674 assertEquals(1, validSourceTypes.size());
675 assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
679 private void testSetRequirements(Resource resource) {
680 Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
681 assertEquals(2, requirements.size());
683 assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
684 List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
685 RequirementDefinition requirement = requirementList.get(0);
686 assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
687 assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
688 assertEquals("link", requirement.getName());
690 assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
691 requirementList = requirements.get("tosca.capabilities.network.Bindable");
692 requirement = requirementList.get(0);
693 assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
694 assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
695 assertEquals("binding", requirement.getName());
699 private void assertSetInterfaceImplementation(final Resource resource) {
700 final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
701 assertNotNull(interfaces);
702 assertEquals(1, interfaces.size());
703 final InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
704 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
705 Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
706 operations.values().forEach(operationDataDefinition ->
707 assertTrue(operations.containsKey(operationDataDefinition.getName())));
710 private void assertSetInterfaceImplementationAfterReimport(final Resource resource) {
711 final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
712 assertNotNull(interfaces);
713 assertEquals(2, interfaces.size());
715 InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
716 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
717 assertFalse(interfaceDefinition.isUserCreated());
718 final Map<String, OperationDataDefinition> operations_1 = interfaceDefinition.getOperations();
719 operations_1.values().forEach(operationDataDefinition -> assertTrue(operations_1.containsKey(operationDataDefinition.getName())));
721 interfaceDefinition = interfaces.get("tosca.interfaces.relationship.Configure");
722 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
723 assertTrue(interfaceDefinition.isUserCreated());
724 final Map<String, OperationDataDefinition> operations_2 = interfaceDefinition.getOperations();
725 operations_2.values().forEach(operationDataDefinition -> assertTrue(operations_2.containsKey(operationDataDefinition.getName())));
728 private void testSetDerivedFrom(Resource resource) {
729 assertEquals(1, resource.getDerivedFrom().size());
730 assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
734 private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
735 assertEquals(resource.getDescription(), resourceMD.getDescription());
736 assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
737 assertEquals(resource.getName(), resourceMD.getName());
738 assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
739 assertEquals(resource.getContactId(), resourceMD.getContactId());
740 assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
741 assertEquals(resourceMD.getTags().size(), resource.getTags().size());
742 for (String tag : resource.getTags()) {
743 assertTrue(resourceMD.getTags().contains(tag));
745 assertEquals(resourceMD.isNormative(), resource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
748 private void testSetConstantMetaData(Resource resource) {
749 assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
750 assertSame(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE, resource.getLifecycleState());
751 assertEquals(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION, resource.isHighestVersion());
752 assertEquals(ImportUtils.Constants.VENDOR_NAME, resource.getVendorName());
753 assertEquals(ImportUtils.Constants.VENDOR_RELEASE, resource.getVendorRelease());
756 protected ServiceCsarInfo getCsarInfo() {
757 String csarUuid = "0010";
758 User user = new User("jh0003");
761 File csarFile = new File(
762 ResourceImportManagerTest.class.getClassLoader().getResource("csars/service-Etsiwithchild-csar.csar").toURI());
763 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
765 String vfReousrceName = "resouceName";
766 String mainTemplateName = "Definitions/service-Etsiwithchild-template.yml";
768 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Etsiwithchild-template.yml")).findAny();
769 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
770 assertNotNull(mainTemplateService);
771 final String mainTemplateContent = new String(mainTemplateService);
773 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false);
774 } catch (URISyntaxException | ZipException e) {