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.mockito.ArgumentMatchers.any;
33 import static org.mockito.ArgumentMatchers.anyMap;
34 import static org.mockito.ArgumentMatchers.anyString;
35 import static org.mockito.ArgumentMatchers.eq;
36 import static org.mockito.Mockito.anyBoolean;
37 import static org.mockito.Mockito.mock;
38 import static org.mockito.Mockito.times;
39 import static org.mockito.Mockito.verify;
40 import static org.mockito.Mockito.when;
42 import fj.data.Either;
43 import java.io.IOException;
44 import java.util.ArrayList;
45 import java.util.Arrays;
46 import java.util.Collections;
47 import java.util.HashMap;
48 import java.util.List;
50 import org.apache.commons.collections4.CollectionUtils;
51 import org.apache.commons.collections4.MapUtils;
52 import org.apache.commons.lang3.tuple.ImmutablePair;
53 import org.junit.jupiter.api.BeforeAll;
54 import org.junit.jupiter.api.BeforeEach;
55 import org.junit.jupiter.api.Test;
56 import org.mockito.stubbing.Answer;
57 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
58 import org.openecomp.sdc.be.components.impl.ImportUtils;
59 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
60 import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
61 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
62 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
63 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
64 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
65 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
66 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
67 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
68 import org.openecomp.sdc.be.config.Configuration;
69 import org.openecomp.sdc.be.config.ConfigurationManager;
70 import org.openecomp.sdc.be.dao.api.ActionStatus;
71 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
72 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
73 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
74 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
75 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
76 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
77 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
79 import org.openecomp.sdc.be.impl.ComponentsUtils;
80 import org.openecomp.sdc.be.model.CapabilityDefinition;
81 import org.openecomp.sdc.be.model.Component;
82 import org.openecomp.sdc.be.model.InterfaceDefinition;
83 import org.openecomp.sdc.be.model.NodeTypeMetadata;
84 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
85 import org.openecomp.sdc.be.model.PropertyConstraint;
86 import org.openecomp.sdc.be.model.PropertyDefinition;
87 import org.openecomp.sdc.be.model.RequirementDefinition;
88 import org.openecomp.sdc.be.model.Resource;
89 import org.openecomp.sdc.be.model.UploadResourceInfo;
90 import org.openecomp.sdc.be.model.User;
91 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
92 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
93 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
94 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
95 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
96 import org.openecomp.sdc.be.user.UserBusinessLogic;
97 import org.openecomp.sdc.be.utils.TypeUtils;
98 import org.openecomp.sdc.common.api.ConfigurationSource;
99 import org.openecomp.sdc.common.impl.ExternalConfiguration;
100 import org.openecomp.sdc.common.impl.FSConfigurationSource;
101 import org.openecomp.sdc.exception.PolicyException;
102 import org.openecomp.sdc.exception.ResponseFormat;
104 class ResourceImportManagerTest {
106 private ResourceImportManager importManager;
108 private final AuditingManager auditingManager = mock(AuditingManager.class);
109 private final ResponseFormatManager responseFormatManager = mock(ResponseFormatManager.class);
110 private final ResourceBusinessLogic resourceBusinessLogic = mock(ResourceBusinessLogic.class);
111 private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = mock(InterfaceOperationBusinessLogic.class);
112 private final InterfaceDefinitionHandler interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
113 private final JanusGraphDao janusGraphDao = mock(JanusGraphDao.class);
114 private final UserBusinessLogic userAdmin = mock(UserBusinessLogic.class);
115 private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
116 private final ComponentsUtils componentsUtils = mock(ComponentsUtils.class);
117 private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
118 private UploadResourceInfo resourceMD;
122 public static void beforeClass() {
123 String appConfigDir = "src/test/resources/config/catalog-be";
124 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
125 final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
127 Configuration configuration = new Configuration();
128 configuration.setJanusGraphInMemoryGraph(true);
129 configurationManager.setConfiguration(configuration);
133 public void beforeTest() {
134 importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler, janusGraphDao);
135 importManager.setAuditingManager(auditingManager);
136 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any())).thenReturn(Either.left(null));
137 when(toscaOperationFacade.getLatestByToscaResourceNameAndModel(anyString(), any())).thenReturn(Either.left(null));
138 importManager.setResponseFormatManager(responseFormatManager);
139 importManager.setResourceBusinessLogic(resourceBusinessLogic);
140 importManager.setToscaOperationFacade(toscaOperationFacade);
141 Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
142 when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
143 any(JsonParseFlagEnum.class), any())).thenReturn(notFound);
144 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
145 .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
146 resourceMD = createDummyResourceMD();
151 void testBasicResourceCreation() throws IOException {
152 user.setUserId(resourceMD.getContactId());
153 user.setRole("ADMIN");
154 user.setFirstName("Jhon");
155 user.setLastName("Doh");
156 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
158 setResourceBusinessLogicMock();
160 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
162 ImmutablePair<Resource, ActionStatus> createResource =
163 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
164 Resource resource = createResource.left;
166 testSetConstantMetaData(resource);
167 testSetMetaDataFromJson(resource, resourceMD);
169 testSetDerivedFrom(resource);
170 testSetProperties(resource);
172 verify(resourceBusinessLogic).propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true),
177 void testReimportVfcToExistedResource() throws IOException {
178 user.setUserId(resourceMD.getContactId());
179 user.setRole("ADMIN");
180 user.setFirstName("John");
181 user.setLastName("Doe");
182 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
184 setResourceBusinessLogicMock();
186 final String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
188 ImmutablePair<Resource, ActionStatus> createResource =
189 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
190 assertNotNull(createResource);
191 Resource resource = createResource.left;
192 assertNotNull(resource);
194 final GraphVertex graphVertex_1 = new GraphVertex();
195 graphVertex_1.setUniqueId("1-2-3-4-5-6-7");
196 graphVertex_1.addMetadataProperty(GraphPropertyEnum.VERSION, "1.1");
197 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
198 .thenReturn(Either.left(Arrays.asList(graphVertex_1)));
199 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
200 createResource = reimportVfc(resource, jsonContent);
201 assertNotNull(createResource);
202 resource = createResource.left;
203 assertNotNull(resource);
204 testPropertiesAfterReimport(resource);
206 final GraphVertex graphVertex_2 = new GraphVertex();
207 graphVertex_2.setUniqueId("11-22-33-44-55-66-77");
208 graphVertex_2.addMetadataProperty(GraphPropertyEnum.VERSION, "2.2");
209 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
210 .thenReturn(Either.left(Arrays.asList(graphVertex_1, graphVertex_2)));
211 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
212 createResource = reimportVfc(resource, jsonContent);
213 assertNotNull(createResource);
214 resource = createResource.left;
215 assertNotNull(resource);
216 testPropertiesAfterReimport(resource);
218 verify(resourceBusinessLogic, times(3))
219 .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
223 void importAllNormativeResourceSuccessTest() {
224 final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
225 var nodeTypeMetadata1 = new NodeTypeMetadata();
226 nodeTypeMetadata1.setToscaName("my.tosca.Type");
227 nodeTypeMetadata1.setName("Type");
228 nodeMetadataList.add(nodeTypeMetadata1);
229 var nodeTypeMetadata2 = new NodeTypeMetadata();
230 nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
231 nodeMetadataList.add(nodeTypeMetadata2);
232 var nodeTypesMetadataList = new NodeTypesMetadataList();
233 nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
234 var yaml = "node_types:\n"
235 + " my.tosca.Type:\n"
236 + " description: a description";
238 when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null));
239 when(resourceBusinessLogic
240 .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
241 .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
243 importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false);
244 verify(janusGraphDao).commit();
248 void importAllNormativeResourceTest_invalidYaml() {
249 var invalidYaml = "node_types: my.tosca.Type:";
251 final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
252 () -> importManager.importAllNormativeResource(invalidYaml, new NodeTypesMetadataList(), new User(), false, false));
253 assertEquals(ActionStatus.INVALID_NODE_TYPES_YAML, actualException.getActionStatus());
257 void importAllNormativeResourceTest_exceptionDuringImportShouldTriggerRollback() {
258 when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(mock(ResponseFormat.class));
259 when(toscaOperationFacade.getLatestByName(any(), any())).thenThrow(new RuntimeException());
261 final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
262 var nodeTypeMetadata1 = new NodeTypeMetadata();
263 nodeTypeMetadata1.setToscaName("my.tosca.Type");
264 nodeMetadataList.add(nodeTypeMetadata1);
265 var nodeTypeMetadata2 = new NodeTypeMetadata();
266 nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
267 nodeMetadataList.add(nodeTypeMetadata2);
268 var nodeTypesMetadataList = new NodeTypesMetadataList();
269 nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
270 var yaml = "node_types:\n"
271 + " my.tosca.Type:\n"
272 + " description: a description";
274 assertThrows(ComponentException.class,
275 () -> importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false));
276 verify(janusGraphDao).rollback();
280 void testResourceCreationFailed() {
281 user.setUserId(resourceMD.getContactId());
282 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
283 ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
285 when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
286 setResourceBusinessLogicMock();
288 String jsonContent = "this is an invalid yml!";
289 ComponentException errorInfoFromTest = null;
291 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
292 } catch (ComponentException e) {
293 errorInfoFromTest = e;
295 assertNotNull(errorInfoFromTest);
296 assertEquals(ActionStatus.GENERAL_ERROR, errorInfoFromTest.getActionStatus());
298 verify(resourceBusinessLogic, times(0))
299 .createOrUpdateResourceByImport(any(Resource.class), eq(user), eq(true), eq(false), eq(true), eq(null), eq(null), eq(false));
300 verify(resourceBusinessLogic, times(0))
301 .propagateStateToCertified(eq(user), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
305 void testResourceCreationWithCapabilities() throws IOException {
306 user.setUserId(resourceMD.getContactId());
307 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
309 setResourceBusinessLogicMock();
311 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
313 ImmutablePair<Resource, ActionStatus> createResource =
314 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
315 Resource resource = createResource.left;
316 testSetCapabilities(resource);
318 verify(resourceBusinessLogic)
319 .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
320 verify(resourceBusinessLogic).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
325 void testResourceCreationWithRequirements() throws IOException {
326 user.setUserId(resourceMD.getContactId());
327 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
329 setResourceBusinessLogicMock();
331 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
333 ImmutablePair<Resource, ActionStatus> createResource =
334 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
335 testSetRequirements(createResource.left);
340 void testResourceCreationWithInterfaceImplementation() throws IOException {
341 user.setUserId(resourceMD.getContactId());
342 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
344 setResourceBusinessLogicMock();
346 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
348 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
349 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
350 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
351 Map<String, OperationDataDefinition> operations = new HashMap<>();
352 operations.put("configure", new OperationDataDefinition());
353 interfaceDefinition.setOperations(operations);
354 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
355 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
357 final ImmutablePair<Resource, ActionStatus> createResource =
358 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
359 assertSetInterfaceImplementation(createResource.left);
363 void testReimportVfcWithInterfaceImplementation() throws IOException {
364 user.setUserId(resourceMD.getContactId());
365 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
367 setResourceBusinessLogicMock();
369 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
371 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
372 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
373 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
374 Map<String, OperationDataDefinition> operations = new HashMap<>();
375 operations.put("configure", new OperationDataDefinition());
376 interfaceDefinition.setOperations(operations);
377 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
378 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
380 ImmutablePair<Resource, ActionStatus> createResource =
381 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
382 assertNotNull(createResource);
383 Resource resource = createResource.getLeft();
384 assertNotNull(resource);
385 assertSetInterfaceImplementation(resource);
387 final GraphVertex graphVertex = new GraphVertex();
388 graphVertex.setUniqueId("1-2-3-4-5-6-7");
389 when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
390 .thenReturn(Either.left(Arrays.asList(graphVertex)));
391 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
392 createResource = reimportVfc(resource, jsonContent);
393 assertNotNull(createResource);
394 resource = createResource.getLeft();
395 assertNotNull(resource);
396 assertSetInterfaceImplementationAfterReimport(resource);
400 void testResourceCreationWithInterfaceImplementation_UnknownInterface() throws IOException {
401 user.setUserId(resourceMD.getContactId());
402 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
404 setResourceBusinessLogicMock();
406 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-unknown-interface-impl.yml");
408 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
409 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
410 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
411 Map<String, OperationDataDefinition> operations = new HashMap<>();
412 operations.put("configure", new OperationDataDefinition());
413 interfaceDefinition.setOperations(operations);
414 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
415 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
417 ImmutablePair<Resource, ActionStatus> createResource =
418 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
419 assertNull(createResource.left.getInterfaces());
423 void testResourceCreationWitInterfaceImplementation_UnknownOperation() throws IOException {
424 user.setUserId(resourceMD.getContactId());
425 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
427 setResourceBusinessLogicMock();
429 String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl-unknown-operation.yml");
431 Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
432 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
433 interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
434 Map<String, OperationDataDefinition> operations = new HashMap<>();
435 operations.put("configure", new OperationDataDefinition());
436 interfaceDefinition.setOperations(operations);
437 interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
438 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
440 ImmutablePair<Resource, ActionStatus> createResource =
441 importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
442 assertNull(createResource.left.getInterfaces());
446 void testResourceCreationFailedVendorReleaseAlreadyExists() throws IOException {
447 user.setUserId(resourceMD.getContactId());
448 user.setRole("ADMIN");
449 user.setFirstName("Jhon");
450 user.setLastName("Doh");
451 when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
453 setResourceBusinessLogicMock();
454 final Either<Component, StorageOperationStatus> foundResourceEither = Either.left(mock(Resource.class));
455 when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
456 any(JsonParseFlagEnum.class), any())).thenReturn(foundResourceEither);
457 when(toscaOperationFacade.isNodeAssociatedToModel(eq(null), any(Resource.class))).thenReturn(true);
459 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
461 var actualException = assertThrows(ByActionStatusComponentException.class,
462 () -> importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false));
463 assertEquals(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, actualException.getActionStatus());
466 private void setResourceBusinessLogicMock() {
467 when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
468 when(resourceBusinessLogic.createOrUpdateResourceByImport(any(Resource.class), any(User.class), anyBoolean(), anyBoolean(), anyBoolean(),
469 eq(null), eq(null), eq(false)))
470 .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
471 Object[] args = invocation.getArguments();
472 return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
476 resourceBusinessLogic.propagateStateToCertified(any(User.class), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false),
477 eq(true), eq(false)))
478 .thenAnswer((Answer<Resource>) invocation -> {
479 Object[] args = invocation.getArguments();
480 return (Resource) args[1];
483 when(resourceBusinessLogic.createResourceByDao(
484 any(Resource.class), any(User.class), any(AuditingActionEnum.class), anyBoolean(), anyBoolean())).thenAnswer(
485 (Answer<Either<Resource, ResponseFormat>>) invocation -> {
486 Object[] args = invocation.getArguments();
487 return Either.left((Resource) args[0]);
490 when(resourceBusinessLogic.validateResourceBeforeCreate(
491 any(Resource.class), any(User.class), any(AuditingActionEnum.class), eq(false), eq(null))).thenAnswer(
492 (Answer<Either<Resource, ResponseFormat>>) invocation -> {
493 Object[] args = invocation.getArguments();
494 return Either.left((Resource) args[0]);
498 when(resourceBusinessLogic.validatePropertiesDefaultValues(any(Resource.class))).thenReturn(true);
501 private ResponseFormat createGeneralErrorInfo() {
502 ResponseFormat responseFormat = new ResponseFormat(500);
503 responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
504 return responseFormat;
507 private UploadResourceInfo createDummyResourceMD() {
508 UploadResourceInfo resourceMD = new UploadResourceInfo();
509 resourceMD.setName("tosca.nodes.BlockStorage");
510 resourceMD.setPayloadName("payLoad");
511 resourceMD.addSubCategory("Generic", "Infrastructure");
512 resourceMD.setContactId("ya107f");
513 resourceMD.setResourceIconPath("defaulticon");
514 resourceMD.setTags(Collections.singletonList("BlockStorage"));
515 resourceMD.setDescription(
516 "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.");
517 resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
518 resourceMD.setNormative(true);
522 private void testSetProperties(Resource resource) {
523 List<PropertyDefinition> propertiesList = resource.getProperties();
525 Map<String, PropertyDefinition> properties = new HashMap<>();
526 for (PropertyDefinition propertyDefinition : propertiesList) {
527 properties.put(propertyDefinition.getName(), propertyDefinition);
530 assertEquals(3, properties.size());
531 assertTrue(properties.containsKey("size"));
532 PropertyDefinition propertyDefinition = properties.get("size");
533 assertEquals("scalar-unit.size", propertyDefinition.getType());
534 assertEquals(1, propertyDefinition.getConstraints().size());
535 PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
536 assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
538 assertTrue(properties.containsKey("volume_id"));
539 propertyDefinition = properties.get("volume_id");
540 assertEquals("string", propertyDefinition.getType());
541 assertFalse(propertyDefinition.isRequired());
543 assertTrue(properties.containsKey("snapshot_id"));
544 propertyDefinition = properties.get("snapshot_id");
545 assertEquals("string", propertyDefinition.getType());
546 assertFalse(propertyDefinition.isRequired());
550 private ImmutablePair<Resource, ActionStatus> reimportVfc(final Resource resource, final String jsonContent) {
551 List<PropertyDefinition> propertiesList = resource.getProperties();
552 if (CollectionUtils.isEmpty(propertiesList)) {
553 propertiesList = new ArrayList<>();
555 final PropertyDefinition propertyDefinition = new PropertyDefinition();
556 propertyDefinition.setName("oneMore");
557 propertyDefinition.setUserCreated(true);
558 propertyDefinition.setType("boolean");
559 propertiesList.add(propertyDefinition);
560 resource.setProperties(propertiesList);
562 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
563 if (MapUtils.isEmpty(interfaces)) {
564 interfaces = new HashMap<>();
566 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
567 interfaceDefinition.setType("tosca.interfaces.relationship.Configure");
568 interfaceDefinition.setUserCreated(true);
569 final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
570 operationDataDefinition.setName("add_source");
571 final Map<String, OperationDataDefinition> operationDataDefinitionMap = new HashMap<>();
572 operationDataDefinitionMap.put(operationDataDefinition.getName(), operationDataDefinition);
573 interfaceDefinition.setOperations(operationDataDefinitionMap);
574 interfaces.put(interfaceDefinition.getType(), interfaceDefinition);
575 resource.setInterfaces(interfaces);
577 return importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
581 private void testPropertiesAfterReimport(Resource resource) {
582 List<PropertyDefinition> propertiesList = resource.getProperties();
584 Map<String, PropertyDefinition> properties = new HashMap<>();
585 for (PropertyDefinition propertyDefinition : propertiesList) {
586 properties.put(propertyDefinition.getName(), propertyDefinition);
589 assertEquals(4, properties.size());
591 assertTrue(properties.containsKey("size"));
592 PropertyDefinition propertyDefinition = properties.get("size");
593 assertEquals("scalar-unit.size", propertyDefinition.getType());
594 assertEquals(1, propertyDefinition.getConstraints().size());
595 PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
596 assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
598 assertTrue(properties.containsKey("volume_id"));
599 propertyDefinition = properties.get("volume_id");
600 assertEquals("string", propertyDefinition.getType());
601 assertFalse(propertyDefinition.isRequired());
602 assertFalse(propertyDefinition.isUserCreated());
604 assertTrue(properties.containsKey("snapshot_id"));
605 propertyDefinition = properties.get("snapshot_id");
606 assertEquals("string", propertyDefinition.getType());
607 assertFalse(propertyDefinition.isRequired());
608 assertFalse(propertyDefinition.isUserCreated());
610 assertTrue(properties.containsKey("oneMore"));
611 propertyDefinition = properties.get("oneMore");
612 assertEquals("boolean", propertyDefinition.getType());
613 assertFalse(propertyDefinition.isRequired());
614 assertTrue(propertyDefinition.isUserCreated());
617 private void testSetCapabilities(Resource resource) {
618 Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
619 assertEquals(3, capabilities.size());
620 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
621 List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
622 CapabilityDefinition capability = capabilityList.get(0);
623 assertEquals("tosca.capabilities.Endpoint", capability.getType());
624 assertEquals("data_endpoint", capability.getName());
626 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
627 capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
628 capability = capabilityList.get(0);
629 assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
630 assertEquals("admin_endpoint", capability.getName());
632 assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
633 capabilityList = capabilities.get("tosca.capabilities.Container");
634 capability = capabilityList.get(0);
635 assertEquals("tosca.capabilities.Container", capability.getType());
636 assertEquals("host", capability.getName());
638 List<String> validSourceTypes = capability.getValidSourceTypes();
639 assertEquals(1, validSourceTypes.size());
640 assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
644 private void testSetRequirements(Resource resource) {
645 Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
646 assertEquals(2, requirements.size());
648 assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
649 List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
650 RequirementDefinition requirement = requirementList.get(0);
651 assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
652 assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
653 assertEquals("link", requirement.getName());
655 assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
656 requirementList = requirements.get("tosca.capabilities.network.Bindable");
657 requirement = requirementList.get(0);
658 assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
659 assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
660 assertEquals("binding", requirement.getName());
664 private void assertSetInterfaceImplementation(final Resource resource) {
665 final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
666 assertNotNull(interfaces);
667 assertEquals(1, interfaces.size());
668 final InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
669 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
670 Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
671 operations.values().forEach(operationDataDefinition ->
672 assertTrue(operations.containsKey(operationDataDefinition.getName())));
675 private void assertSetInterfaceImplementationAfterReimport(final Resource resource) {
676 final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
677 assertNotNull(interfaces);
678 assertEquals(2, interfaces.size());
680 InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
681 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
682 assertFalse(interfaceDefinition.isUserCreated());
683 final Map<String, OperationDataDefinition> operations_1 = interfaceDefinition.getOperations();
684 operations_1.values().forEach(operationDataDefinition -> assertTrue(operations_1.containsKey(operationDataDefinition.getName())));
686 interfaceDefinition = interfaces.get("tosca.interfaces.relationship.Configure");
687 assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
688 assertTrue(interfaceDefinition.isUserCreated());
689 final Map<String, OperationDataDefinition> operations_2 = interfaceDefinition.getOperations();
690 operations_2.values().forEach(operationDataDefinition -> assertTrue(operations_2.containsKey(operationDataDefinition.getName())));
693 private void testSetDerivedFrom(Resource resource) {
694 assertEquals(1, resource.getDerivedFrom().size());
695 assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
699 private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
700 assertEquals(resource.getDescription(), resourceMD.getDescription());
701 assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
702 assertEquals(resource.getName(), resourceMD.getName());
703 assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
704 assertEquals(resource.getContactId(), resourceMD.getContactId());
705 assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
706 assertEquals(resourceMD.getTags().size(), resource.getTags().size());
707 for (String tag : resource.getTags()) {
708 assertTrue(resourceMD.getTags().contains(tag));
710 assertEquals(resourceMD.isNormative(), resource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
713 private void testSetConstantMetaData(Resource resource) {
714 assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
715 assertSame(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE, resource.getLifecycleState());
716 assertEquals(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION, resource.isHighestVersion());
717 assertEquals(ImportUtils.Constants.VENDOR_NAME, resource.getVendorName());
718 assertEquals(ImportUtils.Constants.VENDOR_RELEASE, resource.getVendorRelease());