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.eq;
37 import static org.mockito.Mockito.anyBoolean;
38 import static org.mockito.Mockito.mock;
39 import static org.mockito.Mockito.times;
40 import static org.mockito.Mockito.verify;
41 import static org.mockito.Mockito.when;
43 import fj.data.Either;
45 import java.io.IOException;
46 import java.net.URISyntaxException;
47 import java.util.ArrayList;
48 import java.util.Arrays;
49 import java.util.Collections;
50 import java.util.HashMap;
51 import java.util.List;
53 import java.util.Optional;
54 import org.apache.commons.collections4.CollectionUtils;
55 import org.apache.commons.collections4.MapUtils;
56 import org.apache.commons.lang3.tuple.ImmutablePair;
57 import org.junit.jupiter.api.BeforeAll;
58 import org.junit.jupiter.api.BeforeEach;
59 import org.junit.jupiter.api.Test;
60 import org.mockito.stubbing.Answer;
61 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
62 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
63 import org.openecomp.sdc.be.components.impl.ImportUtils;
64 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
65 import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
66 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
67 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
68 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
69 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
70 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
71 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
72 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
73 import org.openecomp.sdc.be.config.Configuration;
74 import org.openecomp.sdc.be.config.ConfigurationManager;
75 import org.openecomp.sdc.be.dao.api.ActionStatus;
76 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
77 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
78 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
79 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
80 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
81 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
82 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
83 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
84 import org.openecomp.sdc.be.impl.ComponentsUtils;
85 import org.openecomp.sdc.be.model.CapabilityDefinition;
86 import org.openecomp.sdc.be.model.Component;
87 import org.openecomp.sdc.be.model.InterfaceDefinition;
88 import org.openecomp.sdc.be.model.NodeTypeDefinition;
89 import org.openecomp.sdc.be.model.NodeTypeMetadata;
90 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
91 import org.openecomp.sdc.be.model.PropertyConstraint;
92 import org.openecomp.sdc.be.model.PropertyDefinition;
93 import org.openecomp.sdc.be.model.RequirementDefinition;
94 import org.openecomp.sdc.be.model.Resource;
95 import org.openecomp.sdc.be.model.UploadResourceInfo;
96 import org.openecomp.sdc.be.model.User;
97 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
98 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
99 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
100 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
101 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
102 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
103 import org.openecomp.sdc.be.user.UserBusinessLogic;
104 import org.openecomp.sdc.be.utils.TypeUtils;
105 import org.openecomp.sdc.common.api.ConfigurationSource;
106 import org.openecomp.sdc.common.impl.ExternalConfiguration;
107 import org.openecomp.sdc.common.impl.FSConfigurationSource;
108 import org.openecomp.sdc.common.zip.ZipUtils;
109 import org.openecomp.sdc.common.zip.exception.ZipException;
110 import org.openecomp.sdc.exception.PolicyException;
111 import org.openecomp.sdc.exception.ResponseFormat;
113 class ResourceImportManagerTest {
115 private ResourceImportManager importManager;
117 private final AuditingManager auditingManager = mock(AuditingManager.class);
118 private final ResponseFormatManager responseFormatManager = mock(ResponseFormatManager.class);
119 private final ResourceBusinessLogic resourceBusinessLogic = mock(ResourceBusinessLogic.class);
120 private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = mock(InterfaceOperationBusinessLogic.class);
121 private final InterfaceDefinitionHandler interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
122 private final JanusGraphDao janusGraphDao = mock(JanusGraphDao.class);
123 private final UserBusinessLogic userAdmin = mock(UserBusinessLogic.class);
124 private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
125 private final ComponentsUtils componentsUtils = mock(ComponentsUtils.class);
126 private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
127 private UploadResourceInfo resourceMD;
131 public static void beforeClass() {
132 String appConfigDir = "src/test/resources/config/catalog-be";
133 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
134 final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
136 Configuration configuration = new Configuration();
137 configuration.setJanusGraphInMemoryGraph(true);
138 configurationManager.setConfiguration(configuration);
142 public void beforeTest() {
143 importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler, janusGraphDao);
144 importManager.setAuditingManager(auditingManager);
145 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any())).thenReturn(Either.left(null));
146 when(toscaOperationFacade.getLatestByToscaResourceNameAndModel(anyString(), any())).thenReturn(Either.left(null));
147 importManager.setResponseFormatManager(responseFormatManager);
148 importManager.setResourceBusinessLogic(resourceBusinessLogic);
149 importManager.setToscaOperationFacade(toscaOperationFacade);
150 Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
151 when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
152 any(JsonParseFlagEnum.class), any())).thenReturn(notFound);
153 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
154 .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
155 resourceMD = createDummyResourceMD();
160 void testBasicResourceCreation() throws IOException {
161 user.setUserId(resourceMD.getContactId());
162 user.setRole("ADMIN");
163 user.setFirstName("Jhon");
164 user.setLastName("Doh");
165 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
167 setResourceBusinessLogicMock();
169 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
171 ImmutablePair<Resource, ActionStatus> createResource =
172 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
173 Resource resource = createResource.left;
175 testSetConstantMetaData(resource);
176 testSetMetaDataFromJson(resource, resourceMD);
178 testSetDerivedFrom(resource);
179 testSetProperties(resource);
181 verify(resourceBusinessLogic).propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true),
186 void testReimportVfcToExistedResource() throws IOException {
187 user.setUserId(resourceMD.getContactId());
188 user.setRole("ADMIN");
189 user.setFirstName("John");
190 user.setLastName("Doe");
191 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
193 setResourceBusinessLogicMock();
195 final String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
197 ImmutablePair<Resource, ActionStatus> createResource =
198 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
199 assertNotNull(createResource);
200 Resource resource = createResource.left;
201 assertNotNull(resource);
203 final GraphVertex graphVertex_1 = new GraphVertex();
204 graphVertex_1.setUniqueId("1-2-3-4-5-6-7");
205 graphVertex_1.addMetadataProperty(GraphPropertyEnum.VERSION, "1.1");
206 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
207 .thenReturn(Either.left(Arrays.asList(graphVertex_1)));
208 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
209 createResource = reimportVfc(resource, jsonContent);
210 assertNotNull(createResource);
211 resource = createResource.left;
212 assertNotNull(resource);
213 testPropertiesAfterReimport(resource);
215 final GraphVertex graphVertex_2 = new GraphVertex();
216 graphVertex_2.setUniqueId("11-22-33-44-55-66-77");
217 graphVertex_2.addMetadataProperty(GraphPropertyEnum.VERSION, "2.2");
218 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
219 .thenReturn(Either.left(Arrays.asList(graphVertex_1, graphVertex_2)));
220 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
221 createResource = reimportVfc(resource, jsonContent);
222 assertNotNull(createResource);
223 resource = createResource.left;
224 assertNotNull(resource);
225 testPropertiesAfterReimport(resource);
227 verify(resourceBusinessLogic, times(3))
228 .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
232 void importAllNormativeResourceSuccessTest() {
233 final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
234 var nodeTypeMetadata1 = new NodeTypeMetadata();
235 nodeTypeMetadata1.setToscaName("my.tosca.Type");
236 nodeTypeMetadata1.setName("Type");
237 nodeMetadataList.add(nodeTypeMetadata1);
238 var nodeTypeMetadata2 = new NodeTypeMetadata();
239 nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
240 nodeMetadataList.add(nodeTypeMetadata2);
241 var nodeTypesMetadataList = new NodeTypesMetadataList();
242 nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
243 var yaml = "node_types:\n"
244 + " my.tosca.Type:\n"
245 + " description: a description";
247 when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null));
248 when(resourceBusinessLogic
249 .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
250 .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
252 importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false);
253 verify(janusGraphDao).commit();
257 void importAllNormativeResourceTest_invalidYaml() {
258 var invalidYaml = "node_types: my.tosca.Type:";
260 final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
261 () -> importManager.importAllNormativeResource(invalidYaml, new NodeTypesMetadataList(), new User(), false, false));
262 assertEquals(ActionStatus.INVALID_NODE_TYPES_YAML, actualException.getActionStatus());
266 void importAllNormativeResourceTest_exceptionDuringImportShouldTriggerRollback() {
267 when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(mock(ResponseFormat.class));
268 when(toscaOperationFacade.getLatestByName(any(), any())).thenThrow(new RuntimeException());
270 final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
271 var nodeTypeMetadata1 = new NodeTypeMetadata();
272 nodeTypeMetadata1.setToscaName("my.tosca.Type");
273 nodeMetadataList.add(nodeTypeMetadata1);
274 var nodeTypeMetadata2 = new NodeTypeMetadata();
275 nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
276 nodeMetadataList.add(nodeTypeMetadata2);
277 var nodeTypesMetadataList = new NodeTypesMetadataList();
278 nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
279 var yaml = "node_types:\n"
280 + " my.tosca.Type:\n"
281 + " description: a description";
283 assertThrows(ComponentException.class,
284 () -> importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false));
285 verify(janusGraphDao).rollback();
289 void testResourceCreationFailed() {
290 user.setUserId(resourceMD.getContactId());
291 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
292 ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
294 when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
295 setResourceBusinessLogicMock();
297 String jsonContent = "this is an invalid yml!";
298 ComponentException errorInfoFromTest = null;
300 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
301 } catch (ComponentException e) {
302 errorInfoFromTest = e;
304 assertNotNull(errorInfoFromTest);
305 assertEquals(ActionStatus.GENERAL_ERROR, errorInfoFromTest.getActionStatus());
307 verify(resourceBusinessLogic, times(0))
308 .createOrUpdateResourceByImport(any(Resource.class), eq(user), eq(true), eq(false), eq(true), eq(null), eq(null), eq(false));
309 verify(resourceBusinessLogic, times(0))
310 .propagateStateToCertified(eq(user), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
314 void testResourceCreationWithCapabilities() throws IOException {
315 user.setUserId(resourceMD.getContactId());
316 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
318 setResourceBusinessLogicMock();
320 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
322 ImmutablePair<Resource, ActionStatus> createResource =
323 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
324 Resource resource = createResource.left;
325 testSetCapabilities(resource);
327 verify(resourceBusinessLogic)
328 .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
329 verify(resourceBusinessLogic).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
334 void testResourceCreationWithRequirements() throws IOException {
335 user.setUserId(resourceMD.getContactId());
336 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
338 setResourceBusinessLogicMock();
340 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
342 ImmutablePair<Resource, ActionStatus> createResource =
343 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
344 testSetRequirements(createResource.left);
349 void testResourceCreationWithInterfaceImplementation() throws IOException {
350 user.setUserId(resourceMD.getContactId());
351 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
353 setResourceBusinessLogicMock();
355 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
357 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
358 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
359 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
360 Map<String, OperationDataDefinition> operations = new HashMap<>();
361 operations.put("configure", new OperationDataDefinition());
362 interfaceDefinition.setOperations(operations);
363 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
364 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
366 final ImmutablePair<Resource, ActionStatus> createResource =
367 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
368 assertSetInterfaceImplementation(createResource.left);
372 void testReimportVfcWithInterfaceImplementation() throws IOException {
373 user.setUserId(resourceMD.getContactId());
374 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
376 setResourceBusinessLogicMock();
378 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
380 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
381 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
382 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
383 Map<String, OperationDataDefinition> operations = new HashMap<>();
384 operations.put("configure", new OperationDataDefinition());
385 interfaceDefinition.setOperations(operations);
386 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
387 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
389 ImmutablePair<Resource, ActionStatus> createResource =
390 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
391 assertNotNull(createResource);
392 Resource resource = createResource.getLeft();
393 assertNotNull(resource);
394 assertSetInterfaceImplementation(resource);
396 final GraphVertex graphVertex = new GraphVertex();
397 graphVertex.setUniqueId("1-2-3-4-5-6-7");
398 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
399 .thenReturn(Either.left(Arrays.asList(graphVertex)));
400 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
401 createResource = reimportVfc(resource, jsonContent);
402 assertNotNull(createResource);
403 resource = createResource.getLeft();
404 assertNotNull(resource);
405 assertSetInterfaceImplementationAfterReimport(resource);
409 void testResourceCreationWithInterfaceImplementation_UnknownInterface() throws IOException {
410 user.setUserId(resourceMD.getContactId());
411 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
413 setResourceBusinessLogicMock();
415 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-unknown-interface-impl.yml");
417 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
418 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
419 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
420 Map<String, OperationDataDefinition> operations = new HashMap<>();
421 operations.put("configure", new OperationDataDefinition());
422 interfaceDefinition.setOperations(operations);
423 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
424 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
426 ImmutablePair<Resource, ActionStatus> createResource =
427 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
428 assertNull(createResource.left.getInterfaces());
432 void testResourceCreationWitInterfaceImplementation_UnknownOperation() throws IOException {
433 user.setUserId(resourceMD.getContactId());
434 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
436 setResourceBusinessLogicMock();
438 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl-unknown-operation.yml");
440 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
441 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
442 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
443 Map<String, OperationDataDefinition> operations = new HashMap<>();
444 operations.put("configure", new OperationDataDefinition());
445 interfaceDefinition.setOperations(operations);
446 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
447 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
449 ImmutablePair<Resource, ActionStatus> createResource =
450 importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
451 assertNull(createResource.left.getInterfaces());
455 void testResourceCreationFailedVendorReleaseAlreadyExists() throws IOException {
456 user.setUserId(resourceMD.getContactId());
457 user.setRole("ADMIN");
458 user.setFirstName("Jhon");
459 user.setLastName("Doh");
460 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
462 setResourceBusinessLogicMock();
463 final Either<Component, StorageOperationStatus> foundResourceEither = Either.left(mock(Resource.class));
464 when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
465 any(JsonParseFlagEnum.class), any())).thenReturn(foundResourceEither);
466 when(toscaOperationFacade.isNodeAssociatedToModel(eq(null), any(Resource.class))).thenReturn(true);
468 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
470 var actualException = assertThrows(ByActionStatusComponentException.class,
471 () -> importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false));
472 assertEquals(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, actualException.getActionStatus());
476 void getAllResourcesYamlAndNodeTypesMetadataListTest() {
477 NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
478 List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
479 Map<String, Object> allTypesToCreate = new HashMap<>();
480 ServiceCsarInfo csarInfo= getCsarInfo();
481 List<NodeTypeDefinition> nodeTypesToCreate = csarInfo.getNodeTypesUsed();
482 nodeTypesToCreate.stream().forEach(nodeType -> {
483 allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
484 nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
486 nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
488 when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null)).thenReturn(Either.left(null));
489 when(toscaOperationFacade.getLatestByToscaResourceName("org.openecomp.resource.VFC-root", "ETSI SOL001 v2.5.1"))
490 .thenReturn(Either.left(null));
491 when(resourceBusinessLogic
492 .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
493 .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK)).thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
495 importManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, null, user, "", false, false);
496 verify(janusGraphDao).commit();
499 private void setResourceBusinessLogicMock() {
500 when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
501 when(resourceBusinessLogic.createOrUpdateResourceByImport(any(Resource.class), any(User.class), anyBoolean(), anyBoolean(), anyBoolean(),
502 eq(null), eq(null), eq(false)))
503 .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
504 Object[] args = invocation.getArguments();
505 return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
509 resourceBusinessLogic.propagateStateToCertified(any(User.class), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false),
510 eq(true), eq(false)))
511 .thenAnswer((Answer<Resource>) invocation -> {
512 Object[] args = invocation.getArguments();
513 return (Resource) args[1];
516 when(resourceBusinessLogic.createResourceByDao(
517 any(Resource.class), any(User.class), any(AuditingActionEnum.class), anyBoolean(), anyBoolean())).thenAnswer(
518 (Answer<Either<Resource, ResponseFormat>>) invocation -> {
519 Object[] args = invocation.getArguments();
520 return Either.left((Resource) args[0]);
523 when(resourceBusinessLogic.validateResourceBeforeCreate(
524 any(Resource.class), any(User.class), any(AuditingActionEnum.class), eq(false), eq(null))).thenAnswer(
525 (Answer<Either<Resource, ResponseFormat>>) invocation -> {
526 Object[] args = invocation.getArguments();
527 return Either.left((Resource) args[0]);
531 when(resourceBusinessLogic.validatePropertiesDefaultValues(any(Resource.class))).thenReturn(true);
534 private ResponseFormat createGeneralErrorInfo() {
535 ResponseFormat responseFormat = new ResponseFormat(500);
536 responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
537 return responseFormat;
540 private UploadResourceInfo createDummyResourceMD() {
541 UploadResourceInfo resourceMD = new UploadResourceInfo();
542 resourceMD.setName("tosca.nodes.BlockStorage");
543 resourceMD.setPayloadName("payLoad");
544 resourceMD.addSubCategory("Generic", "Infrastructure");
545 resourceMD.setContactId("ya107f");
546 resourceMD.setResourceIconPath("defaulticon");
547 resourceMD.setTags(Collections.singletonList("BlockStorage"));
548 resourceMD.setDescription(
549 "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.");
550 resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
551 resourceMD.setNormative(true);
555 private void testSetProperties(Resource resource) {
556 List<PropertyDefinition> propertiesList = resource.getProperties();
558 Map<String, PropertyDefinition> properties = new HashMap<>();
559 for (PropertyDefinition propertyDefinition : propertiesList) {
560 properties.put(propertyDefinition.getName(), propertyDefinition);
563 assertEquals(3, properties.size());
564 assertTrue(properties.containsKey("size"));
565 PropertyDefinition propertyDefinition = properties.get("size");
566 assertEquals("scalar-unit.size", propertyDefinition.getType());
567 assertEquals(1, propertyDefinition.getConstraints().size());
568 PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
569 assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
571 assertTrue(properties.containsKey("volume_id"));
572 propertyDefinition = properties.get("volume_id");
573 assertEquals("string", propertyDefinition.getType());
574 assertFalse(propertyDefinition.isRequired());
576 assertTrue(properties.containsKey("snapshot_id"));
577 propertyDefinition = properties.get("snapshot_id");
578 assertEquals("string", propertyDefinition.getType());
579 assertFalse(propertyDefinition.isRequired());
583 private ImmutablePair<Resource, ActionStatus> reimportVfc(final Resource resource, final String jsonContent) {
584 List<PropertyDefinition> propertiesList = resource.getProperties();
585 if (CollectionUtils.isEmpty(propertiesList)) {
586 propertiesList = new ArrayList<>();
588 final PropertyDefinition propertyDefinition = new PropertyDefinition();
589 propertyDefinition.setName("oneMore");
590 propertyDefinition.setUserCreated(true);
591 propertyDefinition.setType("boolean");
592 propertiesList.add(propertyDefinition);
593 resource.setProperties(propertiesList);
595 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
596 if (MapUtils.isEmpty(interfaces)) {
597 interfaces = new HashMap<>();
599 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
600 interfaceDefinition.setType("tosca.interfaces.relationship.Configure");
601 interfaceDefinition.setUserCreated(true);
602 final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
603 operationDataDefinition.setName("add_source");
604 final Map<String, OperationDataDefinition> operationDataDefinitionMap = new HashMap<>();
605 operationDataDefinitionMap.put(operationDataDefinition.getName(), operationDataDefinition);
606 interfaceDefinition.setOperations(operationDataDefinitionMap);
607 interfaces.put(interfaceDefinition.getType(), interfaceDefinition);
608 resource.setInterfaces(interfaces);
610 return importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
614 private void testPropertiesAfterReimport(Resource resource) {
615 List<PropertyDefinition> propertiesList = resource.getProperties();
617 Map<String, PropertyDefinition> properties = new HashMap<>();
618 for (PropertyDefinition propertyDefinition : propertiesList) {
619 properties.put(propertyDefinition.getName(), propertyDefinition);
622 assertEquals(4, properties.size());
624 assertTrue(properties.containsKey("size"));
625 PropertyDefinition propertyDefinition = properties.get("size");
626 assertEquals("scalar-unit.size", propertyDefinition.getType());
627 assertEquals(1, propertyDefinition.getConstraints().size());
628 PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
629 assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
631 assertTrue(properties.containsKey("volume_id"));
632 propertyDefinition = properties.get("volume_id");
633 assertEquals("string", propertyDefinition.getType());
634 assertFalse(propertyDefinition.isRequired());
635 assertFalse(propertyDefinition.isUserCreated());
637 assertTrue(properties.containsKey("snapshot_id"));
638 propertyDefinition = properties.get("snapshot_id");
639 assertEquals("string", propertyDefinition.getType());
640 assertFalse(propertyDefinition.isRequired());
641 assertFalse(propertyDefinition.isUserCreated());
643 assertTrue(properties.containsKey("oneMore"));
644 propertyDefinition = properties.get("oneMore");
645 assertEquals("boolean", propertyDefinition.getType());
646 assertFalse(propertyDefinition.isRequired());
647 assertTrue(propertyDefinition.isUserCreated());
650 private void testSetCapabilities(Resource resource) {
651 Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
652 assertEquals(3, capabilities.size());
653 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
654 List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
655 CapabilityDefinition capability = capabilityList.get(0);
656 assertEquals("tosca.capabilities.Endpoint", capability.getType());
657 assertEquals("data_endpoint", capability.getName());
659 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
660 capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
661 capability = capabilityList.get(0);
662 assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
663 assertEquals("admin_endpoint", capability.getName());
665 assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
666 capabilityList = capabilities.get("tosca.capabilities.Container");
667 capability = capabilityList.get(0);
668 assertEquals("tosca.capabilities.Container", capability.getType());
669 assertEquals("host", capability.getName());
671 List<String> validSourceTypes = capability.getValidSourceTypes();
672 assertEquals(1, validSourceTypes.size());
673 assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
677 private void testSetRequirements(Resource resource) {
678 Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
679 assertEquals(2, requirements.size());
681 assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
682 List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
683 RequirementDefinition requirement = requirementList.get(0);
684 assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
685 assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
686 assertEquals("link", requirement.getName());
688 assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
689 requirementList = requirements.get("tosca.capabilities.network.Bindable");
690 requirement = requirementList.get(0);
691 assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
692 assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
693 assertEquals("binding", requirement.getName());
697 private void assertSetInterfaceImplementation(final Resource resource) {
698 final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
699 assertNotNull(interfaces);
700 assertEquals(1, interfaces.size());
701 final InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
702 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
703 Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
704 operations.values().forEach(operationDataDefinition ->
705 assertTrue(operations.containsKey(operationDataDefinition.getName())));
708 private void assertSetInterfaceImplementationAfterReimport(final Resource resource) {
709 final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
710 assertNotNull(interfaces);
711 assertEquals(2, interfaces.size());
713 InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
714 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
715 assertFalse(interfaceDefinition.isUserCreated());
716 final Map<String, OperationDataDefinition> operations_1 = interfaceDefinition.getOperations();
717 operations_1.values().forEach(operationDataDefinition -> assertTrue(operations_1.containsKey(operationDataDefinition.getName())));
719 interfaceDefinition = interfaces.get("tosca.interfaces.relationship.Configure");
720 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
721 assertTrue(interfaceDefinition.isUserCreated());
722 final Map<String, OperationDataDefinition> operations_2 = interfaceDefinition.getOperations();
723 operations_2.values().forEach(operationDataDefinition -> assertTrue(operations_2.containsKey(operationDataDefinition.getName())));
726 private void testSetDerivedFrom(Resource resource) {
727 assertEquals(1, resource.getDerivedFrom().size());
728 assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
732 private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
733 assertEquals(resource.getDescription(), resourceMD.getDescription());
734 assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
735 assertEquals(resource.getName(), resourceMD.getName());
736 assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
737 assertEquals(resource.getContactId(), resourceMD.getContactId());
738 assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
739 assertEquals(resourceMD.getTags().size(), resource.getTags().size());
740 for (String tag : resource.getTags()) {
741 assertTrue(resourceMD.getTags().contains(tag));
743 assertEquals(resourceMD.isNormative(), resource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
746 private void testSetConstantMetaData(Resource resource) {
747 assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
748 assertSame(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE, resource.getLifecycleState());
749 assertEquals(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION, resource.isHighestVersion());
750 assertEquals(ImportUtils.Constants.VENDOR_NAME, resource.getVendorName());
751 assertEquals(ImportUtils.Constants.VENDOR_RELEASE, resource.getVendorRelease());
754 protected ServiceCsarInfo getCsarInfo() {
755 String csarUuid = "0010";
756 User user = new User("jh0003");
759 File csarFile = new File(
760 ResourceImportManagerTest.class.getClassLoader().getResource("csars/service-Etsiwithchild-csar.csar").toURI());
761 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
763 String vfReousrceName = "resouceName";
764 String mainTemplateName = "Definitions/service-Etsiwithchild-template.yml";
766 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Etsiwithchild-template.yml")).findAny();
767 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
768 assertNotNull(mainTemplateService);
769 final String mainTemplateContent = new String(mainTemplateService);
771 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false, mock(ModelOperation.class));
772 } catch (URISyntaxException | ZipException e) {