2 * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.openecomp.sdc.be.components.impl;
19 import static org.assertj.core.api.Java6Assertions.assertThat;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertNotEquals;
22 import static org.junit.jupiter.api.Assertions.assertNotNull;
23 import static org.junit.jupiter.api.Assertions.assertSame;
24 import static org.junit.jupiter.api.Assertions.assertThrows;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 import static org.junit.jupiter.api.Assertions.fail;
27 import static org.mockito.ArgumentMatchers.any;
28 import static org.mockito.ArgumentMatchers.anyBoolean;
29 import static org.mockito.ArgumentMatchers.anyMap;
30 import static org.mockito.ArgumentMatchers.anyString;
31 import static org.mockito.Mockito.mock;
32 import static org.mockito.Mockito.times;
33 import static org.mockito.Mockito.verify;
34 import static org.mockito.Mockito.when;
36 import fj.data.Either;
38 import java.io.IOException;
39 import java.net.URISyntaxException;
40 import java.nio.file.FileSystems;
41 import java.nio.file.Files;
42 import java.util.ArrayList;
43 import java.util.Collections;
44 import java.util.EnumMap;
45 import java.util.HashMap;
46 import java.util.List;
48 import java.util.Map.Entry;
49 import java.util.NoSuchElementException;
50 import java.util.Optional;
51 import org.apache.commons.collections.map.HashedMap;
52 import org.apache.commons.lang3.tuple.ImmutablePair;
53 import org.glassfish.grizzly.http.util.HttpStatus;
54 import org.junit.jupiter.api.Assertions;
55 import org.junit.jupiter.api.BeforeEach;
56 import org.junit.jupiter.api.Test;
57 import org.mockito.MockitoAnnotations;
58 import org.openecomp.sdc.ElementOperationMock;
59 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
60 import org.openecomp.sdc.be.components.csar.CsarInfo;
61 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
62 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
63 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
64 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
65 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
66 import org.openecomp.sdc.be.dao.api.ActionStatus;
67 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
71 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
72 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
73 import org.openecomp.sdc.be.impl.ComponentsUtils;
74 import org.openecomp.sdc.be.model.ArtifactDefinition;
75 import org.openecomp.sdc.be.model.AttributeDefinition;
76 import org.openecomp.sdc.be.model.CapabilityDefinition;
77 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
78 import org.openecomp.sdc.be.model.Component;
79 import org.openecomp.sdc.be.model.ComponentInstance;
80 import org.openecomp.sdc.be.model.ComponentInstanceInput;
81 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
82 import org.openecomp.sdc.be.model.ComponentParametersView;
83 import org.openecomp.sdc.be.model.GroupDefinition;
84 import org.openecomp.sdc.be.model.InputDefinition;
85 import org.openecomp.sdc.be.model.InterfaceDefinition;
86 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
87 import org.openecomp.sdc.be.model.LifecycleStateEnum;
88 import org.openecomp.sdc.be.model.NodeTypeInfo;
89 import org.openecomp.sdc.be.model.OutputDefinition;
90 import org.openecomp.sdc.be.model.PropertyDefinition;
91 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
92 import org.openecomp.sdc.be.model.RequirementDefinition;
93 import org.openecomp.sdc.be.model.Resource;
94 import org.openecomp.sdc.be.model.Service;
95 import org.openecomp.sdc.be.model.UploadCapInfo;
96 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
97 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
98 import org.openecomp.sdc.be.model.UploadPropInfo;
99 import org.openecomp.sdc.be.model.UploadReqInfo;
100 import org.openecomp.sdc.be.model.User;
101 import org.openecomp.sdc.be.model.category.CategoryDefinition;
102 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
103 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
104 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
105 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
106 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
107 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
108 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
109 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
110 import org.openecomp.sdc.be.user.Role;
111 import org.openecomp.sdc.common.api.Constants;
112 import org.openecomp.sdc.common.zip.ZipUtils;
113 import org.openecomp.sdc.common.zip.exception.ZipException;
114 import org.openecomp.sdc.exception.ResponseFormat;
116 class ServiceImportParseLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
118 private static final String RESOURCE_NAME = "My-Resource_Name with space";
119 private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
120 private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
121 private static final String RESOURCE_SUBCATEGORY = "Router";
123 private final ComponentsUtils componentsUtils = new ComponentsUtils(mock(AuditingManager.class));
124 private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
125 private final ServiceBusinessLogic serviceBusinessLogic = mock(ServiceBusinessLogic.class);
126 private final ICapabilityTypeOperation capabilityTypeOperation = mock(ICapabilityTypeOperation.class);
127 private final IElementOperation elementDao = mock(IElementOperation.class);
128 private final IInterfaceLifecycleOperation interfaceTypeOperation = mock(IInterfaceLifecycleOperation.class);
129 private final InputsBusinessLogic inputsBusinessLogic = mock(InputsBusinessLogic.class);
130 private final OutputsBusinessLogic outputsBusinessLogic = mock(OutputsBusinessLogic.class);
131 private final LifecycleBusinessLogic lifecycleBusinessLogic = mock(LifecycleBusinessLogic.class);
132 private final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic = mock(ComponentNodeFilterBusinessLogic.class);
134 private ResponseFormatManager responseManager = null;
135 private User user = null;
136 private ServiceImportParseLogic testSubject;
138 private ServiceImportParseLogic createTestSubject() {
139 return new ServiceImportParseLogic(serviceBusinessLogic, componentsUtils, toscaOperationFacade, lifecycleBusinessLogic, inputsBusinessLogic,
140 null, null, interfaceTypeOperation, capabilityTypeOperation, componentNodeFilterBusinessLogic,
141 groupBusinessLogic, outputsBusinessLogic);
145 public void setup() {
146 MockitoAnnotations.openMocks(this);
149 mockElementDao = new ElementOperationMock();
151 // User data and management
153 user.setUserId("jh0003");
154 user.setFirstName("Jimmi");
155 user.setLastName("Hendrix");
156 user.setRole(Role.ADMIN.name());
157 responseManager = ResponseFormatManager.getInstance();
159 testSubject = createTestSubject();
160 serviceBusinessLogic.setElementDao(elementDao);
164 void testFindNodeTypesArtifactsToHandle() {
165 testSubject = createTestSubject();
166 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
167 final Service service = createServiceObject(false);
168 Assertions.assertNotNull(
169 this.testSubject.findNodeTypesArtifactsToHandle(
170 nodeTypesInfo, getCsarInfo(), service));
175 void testBuildNodeTypeYaml() {
176 Map.Entry<String, Object> nodeNameValue = new Entry<String, Object>() {
178 public String getKey() {
183 public Object getValue() {
188 public Object setValue(Object value) {
192 Map<String, Object> mapToConvert = new HashMap<>();
193 String nodeResourceType = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
195 final CsarInfo csarInfo = getCsarInfo();
196 Assertions.assertThrows(ComponentException.class, () ->
197 testSubject.buildNodeTypeYaml(nodeNameValue, mapToConvert, nodeResourceType, csarInfo));
202 void testFindAddNodeTypeArtifactsToHandle() {
204 Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
205 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
206 String namespace = "namespace";
208 ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
209 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
210 final Service service = createServiceObject(false);
211 Resource resource = new Resource();
212 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
213 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
214 .thenReturn(getCompLatestResult);
216 final CsarInfo csarInfo = getCsarInfo();
217 Assertions.assertThrows(ComponentException.class, () ->
218 testSubject.findAddNodeTypeArtifactsToHandle(csarInfo, nodeTypesArtifactsToHandle, service,
219 extractedVfcsArtifacts, namespace, p1));
224 void testFindAddNodeTypeArtifactsToHandleNotNull() {
226 Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
227 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
228 String namespace = "namespace";
229 List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
230 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
231 artifactDefinition.setArtifactName("artifactDefinitionName");
232 vfcArtifacts.add(artifactDefinition);
233 extractedVfcsArtifacts.put(namespace, vfcArtifacts);
234 ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
235 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
236 final Service service = createServiceObject(false);
237 Resource resource = new Resource();
238 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
239 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
240 .thenReturn(getCompLatestResult);
241 Assertions.assertNotNull(extractedVfcsArtifacts);
242 testSubject.findAddNodeTypeArtifactsToHandle(getCsarInfo(), nodeTypesArtifactsToHandle, service,
243 extractedVfcsArtifacts, namespace, p1);
247 void testHandleAndAddExtractedVfcsArtifacts() {
248 List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
249 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
250 artifactDefinition.setArtifactName("artifactDefinitionName");
251 vfcArtifacts.add(artifactDefinition);
252 List<ArtifactDefinition> artifactsToAdd = new ArrayList<>();
253 ArtifactDefinition artifactDefinitionToAdd = new ArtifactDefinition();
254 artifactDefinitionToAdd.setArtifactName("artifactDefinitionToAddName");
255 artifactsToAdd.add(artifactDefinitionToAdd);
256 Assertions.assertNotNull(vfcArtifacts);
258 testSubject.handleAndAddExtractedVfcsArtifacts(vfcArtifacts, artifactsToAdd);
262 void testFindNodeTypeArtifactsToHandle() {
264 Resource curNodeType = createParseResourceObject(true);
265 List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
267 Assertions.assertNull(
268 testSubject.findNodeTypeArtifactsToHandle(curNodeType, extractedArtifacts));
272 void testCollectExistingArtifacts() {
274 Resource curNodeType = createParseResourceObject(true);
275 Assertions.assertNotNull(
276 testSubject.collectExistingArtifacts(curNodeType));
280 void testPutFoundArtifacts() {
281 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
282 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
283 artifactsToUpload.add(artifactDefinition);
284 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
285 artifactsToUpdate.add(artifactDefinition);
286 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
287 artifactsToDelete.add(artifactDefinition);
288 Assertions.assertNotNull(
289 testSubject.putFoundArtifacts(artifactsToUpload, artifactsToUpdate, artifactsToDelete));
293 void testProcessExistingNodeTypeArtifacts() {
294 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
295 List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
296 extractedArtifacts.add(artifactDefinition);
297 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
298 artifactsToUpload.add(artifactDefinition);
299 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
300 artifactsToUpdate.add(artifactDefinition);
301 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
302 artifactsToDelete.add(artifactDefinition);
303 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
304 existingArtifacts.put("test", artifactDefinition);
305 Assertions.assertThrows(ComponentException.class, () ->
306 testSubject.processExistingNodeTypeArtifacts(extractedArtifacts, artifactsToUpload, artifactsToUpdate,
307 artifactsToDelete, existingArtifacts));
312 void testProcessNodeTypeArtifact() {
313 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
314 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
315 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
316 ArtifactDefinition existingArtifact = new ArtifactDefinition();
317 existingArtifact.setArtifactName("ArtifactName");
318 existingArtifact.setArtifactType("ArtifactType");
319 existingArtifact.setArtifactChecksum("ArtifactChecksum");
320 existingArtifacts.put("existingArtifactMap", existingArtifact);
321 ArtifactDefinition currNewArtifact = new ArtifactDefinition();
322 currNewArtifact.setArtifactName("ArtifactName");
323 currNewArtifact.setArtifactType("ArtifactType");
324 currNewArtifact.setPayload("Payload".getBytes());
325 Assertions.assertNotNull(existingArtifact);
326 testSubject.processNodeTypeArtifact(artifactsToUpload, artifactsToUpdate, existingArtifacts, currNewArtifact);
330 void testUpdateFoundArtifact() {
331 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
332 ArtifactDefinition currNewArtifact = new ArtifactDefinition();
333 currNewArtifact.setArtifactChecksum("090909");
334 currNewArtifact.setPayloadData("data");
335 ArtifactDefinition foundArtifact = new ArtifactDefinition();
336 foundArtifact.setArtifactChecksum("08767");
337 Assertions.assertNotNull(currNewArtifact);
339 testSubject.updateFoundArtifact(artifactsToUpdate, currNewArtifact, foundArtifact);
343 void testIsArtifactDeletionRequired() {
344 String artifactId = "artifactId";
345 byte[] artifactFileBytes = new byte[100];
346 boolean isFromCsar = true;
347 Assertions.assertFalse(testSubject.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar));
351 void testFillGroupsFinalFields() {
352 List<GroupDefinition> groupsAsList = new ArrayList<>();
353 GroupDefinition groupDefinition = new GroupDefinition();
354 groupDefinition.setName("groupDefinitionName");
355 groupsAsList.add(groupDefinition);
356 Assertions.assertNotNull(groupsAsList);
357 testSubject.fillGroupsFinalFields(groupsAsList);
361 void testGetComponentTypeForResponse() {
362 Resource resource = createParseResourceObject(true);
363 Assertions.assertNotNull(
364 testSubject.getComponentTypeForResponse(resource));
368 void testGetComponentTypeForResponseByService() {
369 Service service = createServiceObject(true);
370 Assertions.assertNotNull(
371 testSubject.getComponentTypeForResponse(service));
375 void testBuildValidComplexVfc() {
376 Resource resource = createParseResourceObject(true);
377 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
378 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
379 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
380 List<String> derivedFrom = new ArrayList<>();
381 derivedFrom.add("derivedFrom");
382 nodeTypeInfo.setDerivedFrom(derivedFrom);
383 nodesInfo.put(nodeName, nodeTypeInfo);
384 final CsarInfo csarInfo = getCsarInfo();
385 Assertions.assertThrows(ComponentException.class, () ->
386 testSubject.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo));
391 void testValidateResourceBeforeCreate() {
392 Resource resource = createParseResourceObject(true);
394 testSubject.getServiceBusinessLogic().setElementDao(elementDao);
395 final CsarInfo csarInfo = getCsarInfo();
396 Assertions.assertThrows(ComponentException.class, () ->
397 testSubject.validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, false, csarInfo));
402 void testValidateResourceType() {
403 Resource resource = createParseResourceObject(true);
404 Assertions.assertNotNull(
405 testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
409 void testValidateResourceTypeIsEmpty() {
410 Resource resource = new Resource();
411 resource.setResourceType(null);
412 Assertions.assertNotNull(
413 testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
417 void testValidateLifecycleTypesCreate() {
418 Resource resource = createParseResourceObject(true);
419 Map<String, InterfaceDefinition> mapInterfaces = new HashMap<>();
420 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
421 String uniqueId = "01932342212";
422 interfaceDefinition.setUniqueId(uniqueId);
423 mapInterfaces.put("uniqueId", interfaceDefinition);
424 resource.setInterfaces(mapInterfaces);
425 when(interfaceTypeOperation.getInterface(anyString()))
426 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
427 Assertions.assertNotNull(
428 testSubject.validateLifecycleTypesCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
432 void testValidateCapabilityTypesCreate() {
433 Resource resource = createParseResourceObject(true);
434 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
435 String uniqueId = "18982938994";
436 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
437 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
438 capabilityDefinitionList.add(capabilityDefinition);
439 capabilities.put(uniqueId, capabilityDefinitionList);
440 resource.setCapabilities(capabilities);
441 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
442 thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
443 Assertions.assertNotNull(
444 testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
445 AuditingActionEnum.IMPORT_RESOURCE, true));
450 void testValidateCapabilityTypesCreateWhenHaveCapability() {
451 Resource resource = createParseResourceObject(true);
452 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
453 String uniqueId = "18982938994";
454 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
455 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
456 capabilityDefinitionList.add(capabilityDefinition);
457 capabilities.put(uniqueId, capabilityDefinitionList);
458 resource.setCapabilities(capabilities);
459 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
460 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
461 thenReturn(Either.left(capabilityTypeDefinition));
463 Assertions.assertNotNull(
464 testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
465 AuditingActionEnum.IMPORT_RESOURCE, true));
470 void testValidateCapabilityTypeExists() {
471 Resource resource = createParseResourceObject(true);
472 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
473 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
475 Assertions.assertNotNull(
476 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
477 AuditingActionEnum.IMPORT_RESOURCE,
478 eitherResult, typeEntry, false));
483 void testValidateCapabilityTypeExistsWhenPropertiesIsNull() {
484 Resource resource = createParseResourceObject(true);
485 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
486 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
488 String uniqueId = "0987348532";
489 PropertyDefinition propertyDefinition = new PropertyDefinition();
490 Map<String, PropertyDefinition> properties = new HashMap<>();
491 properties.put(uniqueId, propertyDefinition);
492 capabilityTypeDefinition.setProperties(properties);
494 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
495 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
496 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
497 capabilityDefinitionList.add(capabilityDefinition);
498 capabilities.put(uniqueId, capabilityDefinitionList);
499 resource.setCapabilities(capabilities);
501 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
502 thenReturn(Either.left(capabilityTypeDefinition));
503 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
505 Assertions.assertNotNull(
506 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
507 AuditingActionEnum.IMPORT_RESOURCE,
508 eitherResult, typeEntry, false));
513 void testValidateCapabilityTypeExistsWhenPropertiesNotNull() {
514 Resource resource = createParseResourceObject(true);
515 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
516 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
518 String uniqueId = "0987348532";
519 PropertyDefinition propertyDefinition = new PropertyDefinition();
520 propertyDefinition.setName(uniqueId);
521 Map<String, PropertyDefinition> properties = new HashMap<>();
522 properties.put(uniqueId, propertyDefinition);
523 capabilityTypeDefinition.setProperties(properties);
525 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
527 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
528 List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
529 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
530 componentInstanceProperty.setValueUniqueUid(uniqueId);
531 componentInstanceProperty.setName(uniqueId);
532 componentInstancePropertyList.add(componentInstanceProperty);
533 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
534 capabilityDefinition.setProperties(componentInstancePropertyList);
535 capabilityDefinitionList.add(capabilityDefinition);
537 capabilities.put(uniqueId, capabilityDefinitionList);
538 resource.setCapabilities(capabilities);
540 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
541 thenReturn(Either.left(capabilityTypeDefinition));
542 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
544 Assertions.assertNotNull(
545 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
546 AuditingActionEnum.IMPORT_RESOURCE,
547 eitherResult, typeEntry, false));
552 void testValidateCapabilityTypeExists2() {
553 Resource resource = createParseResourceObject(true);
554 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
555 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
556 thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
558 for (String type : resource.getRequirements().keySet()) {
559 Assertions.assertNotNull(
560 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
561 resource.getRequirements().get(type), AuditingActionEnum.IMPORT_RESOURCE, eitherResult, type,
568 void testValidateResourceFieldsBeforeCreate() {
569 Resource resource = createParseResourceObject(true);
570 Assertions.assertThrows(ComponentException.class, () ->
571 testSubject.validateResourceFieldsBeforeCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
575 void testValidateDerivedFromExist() {
576 Resource resource = createParseResourceObject(true);
577 when(toscaOperationFacade.validateToscaResourceNameExists(anyString())).thenReturn(Either.left(true));
578 Assertions.assertNotNull(resource);
580 testSubject.validateDerivedFromExist(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
584 void testValidateLicenseType() {
585 Resource resource = createParseResourceObject(true);
587 Assertions.assertThrows(ComponentException.class, () ->
588 testSubject.validateLicenseType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
594 void testValidateCost() {
595 Resource resource = createParseResourceObject(true);
596 Assertions.assertThrows(ComponentException.class, () ->
597 testSubject.validateCost(resource));
601 void testValidateResourceVendorModelNumber() {
602 Resource resource = createParseResourceObject(true);
603 Assertions.assertNotNull(resource);
605 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
609 void testValidateResourceVendorModelNumberWrongLen() {
610 Resource resource = createParseResourceObject(true);
611 resource.setResourceVendorModelNumber("000000000011122221111222333444443222556677788778889999998776554332340");
612 Assertions.assertThrows(ComponentException.class, () ->
613 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
617 void testValidateResourceVendorModelNumberWrongValue() {
618 Resource resource = createParseResourceObject(true);
619 resource.setResourceVendorModelNumber("");
620 Assertions.assertNotNull(resource);
622 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
626 void testValidateVendorReleaseName() {
627 Resource resource = createParseResourceObject(true);
628 resource.setVendorRelease("0.1");
629 Assertions.assertNotNull(resource);
631 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
635 void testValidateVendorReleaseNameFailure() {
636 Resource resource = createParseResourceObject(true);
637 resource.setVendorRelease("");
638 Assertions.assertThrows(ComponentException.class, () ->
639 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
644 void testValidateVendorReleaseNameWrongLen() {
645 Resource resource = createParseResourceObject(true);
646 resource.setVendorRelease("000000000011122221111222333444443222556677788778889999998776554332340");
647 Assertions.assertThrows(ComponentException.class, () ->
648 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
653 void testValidateCategory() {
654 Resource resource = createParseResourceObject(true);
655 Assertions.assertThrows(ComponentException.class, () ->
656 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
660 void testValidateEmptyCategory() {
661 Resource resource = createParseResourceObject(true);
662 resource.setCategories(null);
663 Assertions.assertThrows(ComponentException.class, () ->
664 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
669 void testValidateCategorySizeBiggerThan1() {
670 Resource resource = createParseResourceObject(true);
671 List<CategoryDefinition> categories = new ArrayList<>();
672 CategoryDefinition categoryDefinition1 = new CategoryDefinition();
673 CategoryDefinition categoryDefinition2 = new CategoryDefinition();
674 categories.add(categoryDefinition1);
675 categories.add(categoryDefinition2);
677 resource.setCategories(categories);
678 Assertions.assertThrows(ComponentException.class, () ->
679 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
684 void testValidateEmptySubCategory() {
685 Resource resource = createParseResourceObject(true);
686 List<CategoryDefinition> categories = resource.getCategories();
687 CategoryDefinition categoryDefinition = categories.get(0);
688 categoryDefinition.setSubcategories(null);
690 Assertions.assertThrows(ComponentException.class, () ->
691 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
696 void testValidateEmptySubCategorySizeBiggerThan1() {
697 Resource resource = createParseResourceObject(true);
698 List<CategoryDefinition> categories = resource.getCategories();
699 CategoryDefinition categoryDefinition = categories.get(0);
700 List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
701 SubCategoryDefinition subCategoryDefinition1 = new SubCategoryDefinition();
702 SubCategoryDefinition subCategoryDefinition2 = new SubCategoryDefinition();
703 subcategories.add(subCategoryDefinition1);
704 subcategories.add(subCategoryDefinition2);
706 Assertions.assertThrows(ComponentException.class, () ->
707 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
712 void testValidateEmptyCategoryName() {
713 Resource resource = createParseResourceObject(true);
714 List<CategoryDefinition> categories = resource.getCategories();
715 CategoryDefinition categoryDefinition = categories.get(0);
716 categoryDefinition.setName(null);
718 Assertions.assertThrows(ComponentException.class, () ->
719 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
723 void testValidateEmptySubCategoryName() {
724 Resource resource = createParseResourceObject(true);
725 List<CategoryDefinition> categories = resource.getCategories();
726 CategoryDefinition categoryDefinition = categories.get(0);
727 List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
728 SubCategoryDefinition subCategoryDefinition1 = subcategories.get(0);
729 subCategoryDefinition1.setName(null);
731 Assertions.assertThrows(ComponentException.class, () ->
732 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
736 void testValidateCategoryListed() {
737 Resource resource = createParseResourceObject(true);
738 CategoryDefinition category = resource.getCategories().get(0);
739 SubCategoryDefinition subcategory = category.getSubcategories().get(0);
740 Assertions.assertThrows(ComponentException.class, () ->
741 testSubject.validateCategoryListed(category, subcategory, user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
745 void testFailOnInvalidCategory() {
746 Resource resource = createParseResourceObject(true);
747 Assertions.assertThrows(ComponentException.class, () ->
748 testSubject.failOnInvalidCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
753 void testValidateVendorName() {
754 Resource resource = createParseResourceObject(true);
755 Assertions.assertNotNull(resource);
756 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
760 void testValidateVendorNameEmpty() {
761 Resource resource = createParseResourceObject(true);
762 resource.setVendorName(null);
763 Assertions.assertThrows(ComponentException.class, () ->
764 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
768 void testValidateVendorNameWrongLen() {
769 Resource resource = createParseResourceObject(true);
770 resource.setVendorName("000000000011122221111222333444443222556677788778889999998776554332340");
771 Assertions.assertThrows(ComponentException.class, () ->
772 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
776 void testValidateVendorName2() {
777 Resource resource = createParseResourceObject(true);
778 CategoryDefinition category = resource.getCategories().get(0);
779 SubCategoryDefinition subcategory = category.getSubcategories().get(0);
780 String vendorName = "vendorName";
781 Assertions.assertNotNull(resource);
783 testSubject.validateVendorName(vendorName, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
787 void testFillResourceMetadata2() {
788 String yamlName = "yamlName";
789 Resource resourceVf = createParseResourceObject(true);
790 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
791 resourceVf.setSystemName("systemName");
792 Assertions.assertThrows(ComponentException.class, () ->
793 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
797 void testFillResourceMetadataWrongStart() {
798 String yamlName = "yamlName";
799 Resource resourceVf = createParseResourceObject(true);
800 String nodeName = "WrongStart" + "test";
801 Assertions.assertThrows(ComponentException.class, () ->
802 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
806 void testFillResourceMetadataResourceTypeIsAbs() {
807 String yamlName = "yamlName";
808 Resource resourceVf = createParseResourceObject(true);
809 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + Constants.ABSTRACT;
810 Assertions.assertNotNull(
811 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
815 void testGetNodeTypeActualName() {
816 String fullName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
817 Assertions.assertNotNull(
818 testSubject.getNodeTypeActualName(fullName));
822 void testAddInput() {
823 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
824 InputDefinition prop = new InputDefinition();
825 Assertions.assertNotNull(currPropertiesMap);
827 testSubject.addInput(currPropertiesMap, prop);
831 void testFindAviableRequirement() {
832 String uniqueId = "101929382910";
833 String regName = uniqueId;
834 String yamlName = uniqueId;
835 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
836 ComponentInstance currentCompInstance = new ComponentInstance();
838 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
839 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
840 RequirementDefinition requirementDefinition = new RequirementDefinition();
841 requirementDefinition.setName(uniqueId);
842 requirementDefinition.setMaxOccurrences("10");
843 requirementDefinition.setLeftOccurrences("3");
844 requirementDefinitionList.add(requirementDefinition);
845 requirements.put(uniqueId, requirementDefinitionList);
846 currentCompInstance.setRequirements(requirements);
848 String capName = "capName";
850 Assertions.assertNotNull(
851 testSubject.findAvailableRequirement(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
855 void testFindAviableRequirementSameCapName() {
856 String uniqueId = "101929382910";
857 String regName = uniqueId;
858 String yamlName = uniqueId;
859 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
860 ComponentInstance currentCompInstance = new ComponentInstance();
862 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
863 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
864 RequirementDefinition requirementDefinition = new RequirementDefinition();
865 requirementDefinition.setName(uniqueId);
866 requirementDefinition.setMaxOccurrences("10");
867 requirementDefinition.setLeftOccurrences("3");
868 requirementDefinitionList.add(requirementDefinition);
869 requirements.put(uniqueId, requirementDefinitionList);
870 currentCompInstance.setRequirements(requirements);
872 String capName = uniqueId;
873 Assertions.assertNotNull(
874 testSubject.findAvailableRequirement(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
878 void testFindAvailableCapabilityByTypeOrName() {
879 RequirementDefinition validReq = new RequirementDefinition();
880 ComponentInstance currentCapCompInstance = new ComponentInstance();
881 UploadReqInfo uploadReqInfo = new UploadReqInfo();
883 Assertions.assertThrows(ComponentException.class, () ->
884 testSubject.findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadReqInfo));
888 void testFindAvailableCapability() {
889 String uniqueId = "23422345677";
890 RequirementDefinition validReq = new RequirementDefinition();
891 validReq.setCapability(uniqueId);
892 ComponentInstance instance = new ComponentInstance();
893 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
894 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
895 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
896 capabilityDefinition.setMaxOccurrences("3");
897 capabilityDefinition.setLeftOccurrences("2");
898 capabilityDefinitionList.add(capabilityDefinition);
899 capabilityMap.put(uniqueId, capabilityDefinitionList);
900 instance.setCapabilities(capabilityMap);
902 Assertions.assertNotNull(
903 testSubject.findAvailableCapability(validReq, instance));
907 void testfindAvailableCapability2() {
908 String uniqueId = "23422345677";
909 RequirementDefinition validReq = new RequirementDefinition();
910 validReq.setCapability(uniqueId);
911 ComponentInstance instance = new ComponentInstance();
912 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
913 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
914 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
915 capabilityDefinition.setName(uniqueId);
916 capabilityDefinition.setMaxOccurrences("3");
917 capabilityDefinition.setLeftOccurrences("2");
918 capabilityDefinitionList.add(capabilityDefinition);
919 capabilityMap.put(uniqueId, capabilityDefinitionList);
920 instance.setCapabilities(capabilityMap);
921 UploadReqInfo uploadReqInfo = new UploadReqInfo();
922 uploadReqInfo.setCapabilityName(uniqueId);
924 Assertions.assertNotNull(
925 testSubject.findAvailableCapability(validReq, instance, uploadReqInfo));
929 void testGetComponentWithInstancesFilter() {
931 Assertions.assertNotNull(
932 testSubject.getComponentWithInstancesFilter());
936 void testCreateParseResourceObject() {
937 String key = "0923928394";
938 List<UploadCapInfo> capabilities = new ArrayList<>();
939 UploadCapInfo uploadCapInfo = new UploadCapInfo();
940 uploadCapInfo.setType(key);
941 capabilities.add(uploadCapInfo);
943 String resourceId = "resourceId";
944 Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
945 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
946 capabilityDefinition.setName(key);
947 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
948 capabilityDefinitionList.add(capabilityDefinition);
949 defaultCapabilities.put(key, capabilityDefinitionList);
951 Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
952 InputDefinition prop = new InputDefinition();
954 Resource resource = createParseResourceObject(true);
955 Map<String, List<CapabilityDefinition>> capabilitiesMap = resource.getCapabilities();
956 capabilitiesMap.put(key, capabilityDefinitionList);
958 when(toscaOperationFacade.getToscaFullElement(anyString()))
959 .thenReturn(Either.left(resource));
961 Assertions.assertNotNull(resource);
963 testSubject.addValidComponentInstanceCapabilities(key, capabilities, resourceId, defaultCapabilities,
964 validCapabilitiesMap);
968 void testGetCapabilityFailure() {
969 String resourceId = "resourceId";
970 String key = "0923928394";
971 Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
972 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
973 capabilityDefinition.setName(key);
974 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
975 capabilityDefinitionList.add(capabilityDefinition);
976 defaultCapabilities.put(key, capabilityDefinitionList);
977 String capabilityType = key;
978 when(toscaOperationFacade.getToscaFullElement(anyString()))
979 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
980 Assertions.assertThrows(ComponentException.class, () ->
981 testSubject.getCapability(resourceId, defaultCapabilities, capabilityType));
985 void testValidateCapabilityProperties() {
986 List<UploadCapInfo> capabilities = new ArrayList<>();
987 UploadCapInfo uploadCapInfo = new UploadCapInfo();
988 List<UploadPropInfo> properties = new ArrayList<>();
989 UploadPropInfo uploadPropInfo = new UploadPropInfo();
990 properties.add(uploadPropInfo);
991 uploadCapInfo.setProperties(properties);
992 capabilities.add(uploadCapInfo);
993 String resourceId = "resourceId";
994 CapabilityDefinition defaultCapability = new CapabilityDefinition();
995 defaultCapability.setProperties(null);
996 defaultCapability.setName("test");
998 Assertions.assertThrows(ComponentException.class, () ->
999 testSubject.validateCapabilityProperties(capabilities, resourceId, defaultCapability));
1003 void testValidateUniquenessUpdateUploadedComponentInstanceCapability() {
1004 String key = "02124568";
1005 List<UploadCapInfo> capabilities = new ArrayList<>();
1006 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1007 List<UploadPropInfo> properties = new ArrayList<>();
1008 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1009 uploadPropInfo.setName(key);
1010 properties.add(uploadPropInfo);
1011 uploadCapInfo.setProperties(properties);
1012 capabilities.add(uploadCapInfo);
1013 String resourceId = "resourceId";
1014 CapabilityDefinition defaultCapability = new CapabilityDefinition();
1015 List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
1016 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
1017 componentInstancePropertyList.add(componentInstanceProperty);
1018 defaultCapability.setProperties(componentInstancePropertyList);
1019 defaultCapability.setName(key);
1021 Assertions.assertNotNull(defaultCapability);
1023 testSubject.validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, uploadCapInfo);
1027 void testSetDeploymentArtifactsPlaceHolderByResource() {
1028 Resource resource = createParseResourceObject(true);
1030 Assertions.assertNotNull(resource);
1032 testSubject.setDeploymentArtifactsPlaceHolder(resource, user);
1036 void testSetDeploymentArtifactsPlaceHolderByService() {
1037 Service Service = createServiceObject(true);
1039 Assertions.assertNotNull(Service);
1041 testSubject.setDeploymentArtifactsPlaceHolder(Service, user);
1045 void testProcessDeploymentResourceArtifacts() {
1046 Resource resource = createParseResourceObject(true);
1047 resource.setResourceType(ResourceTypeEnum.VF);
1048 Map<String, ArtifactDefinition> artifactMap = new HashMap<>();
1050 Object v = new Object();
1051 Map<String, List<String>> artifactDetails = new HashMap<>();
1052 List<String> artifactTypes = new ArrayList<>();
1053 artifactTypes.add(ResourceTypeEnum.VF.name());
1054 artifactDetails.put("validForResourceTypes", artifactTypes);
1055 v = artifactDetails;
1056 Assertions.assertNotNull(resource);
1058 testSubject.processDeploymentResourceArtifacts(user, resource, artifactMap, k, v);
1062 void testMergeOldResourceMetadataWithNew() {
1063 Resource oldResource = createParseResourceObject(true);
1064 Resource newResource = new Resource();
1066 Assertions.assertNotNull(oldResource);
1068 testSubject.mergeOldResourceMetadataWithNew(oldResource, newResource);
1072 void testBuildComplexVfcMetadata() {
1073 Resource resource = createParseResourceObject(true);
1074 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1075 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1076 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1077 List<String> derivedFrom = new ArrayList<>();
1078 derivedFrom.add("derivedFrom");
1079 nodeTypeInfo.setDerivedFrom(derivedFrom);
1080 nodesInfo.put(nodeName, nodeTypeInfo);
1082 Assertions.assertNotNull(
1083 testSubject.buildComplexVfcMetadata(getCsarInfo(), nodeName, nodesInfo));
1087 void testValidateResourceCreationFromNodeType() {
1088 Resource resource = createParseResourceObject(true);
1089 resource.setDerivedFrom(null);
1090 Assertions.assertThrows(ComponentException.class, () ->
1091 testSubject.validateResourceCreationFromNodeType(resource, user));
1095 void testCreateInputsOnResource() {
1096 Resource resource = createParseResourceObject(true);
1097 Map<String, InputDefinition> inputs = new HashMap<>();
1099 Assertions.assertNotNull(
1100 testSubject.createInputsOnResource(resource, inputs));
1104 void testCreateInputsOnResourceWhenIsNotEmpty() {
1105 String key = "12345667";
1106 Resource resource = createParseResourceObject(true);
1107 List<InputDefinition> inputDefinitionList = new ArrayList<>();
1108 InputDefinition inputDefinition = new InputDefinition();
1109 inputDefinitionList.add(inputDefinition);
1110 resource.setInputs(inputDefinitionList);
1111 Map<String, InputDefinition> inputs = new HashMap<>();
1112 inputs.put(key, inputDefinition);
1113 when(inputsBusinessLogic.createInputsInGraph(anyMap(),
1114 any(Component.class))).thenReturn(Either.left(inputDefinitionList));
1115 when(toscaOperationFacade
1116 .getToscaElement(anyString())).thenReturn(Either.left(resource));
1117 Assertions.assertNotNull(
1118 testSubject.createInputsOnResource(resource, inputs));
1122 void testCreateInputsOnService() {
1123 Service service = createServiceObject(true);
1124 List<InputDefinition> resourceProperties = new ArrayList<>();
1125 InputDefinition inputDefinition = new InputDefinition();
1126 inputDefinition.setName("inputDefinitionName");
1127 service.setInputs(resourceProperties);
1128 Map<String, InputDefinition> inputs = new HashMap<>();
1129 InputDefinition inputDefinitionMap = new InputDefinition();
1130 inputDefinition.setName("inputDefinitionName");
1131 inputs.put("inputsMap", inputDefinitionMap);
1132 List<InputDefinition> inputDefinitionList = new ArrayList<>();
1133 Service newService = new Service();
1135 when(inputsBusinessLogic.createInputsInGraph(any(Map.class), any(Component.class)))
1136 .thenReturn(Either.left(inputDefinitionList));
1137 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
1138 Service inputsOnService = testSubject.createInputsOnService(service, inputs);
1139 assertNotNull(inputsOnService);
1143 void testCreateOutputsOnService_OK() {
1144 Service service = createServiceObject(true);
1145 List<OutputDefinition> resourceOutputs = new ArrayList<>();
1146 OutputDefinition outputDefinition = new OutputDefinition();
1147 resourceOutputs.add(outputDefinition);
1148 outputDefinition.setName("outputDefinitionName");
1149 service.setOutputs(resourceOutputs);
1150 Map<String, OutputDefinition> outputs = new HashMap<>();
1151 outputs.put("outputsMap", outputDefinition);
1153 when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId())).thenReturn(Either.left(resourceOutputs));
1154 when(toscaOperationFacade.getToscaElement(service.getUniqueId())).thenReturn(Either.left(service));
1155 Service outputsOnService = testSubject.createOutputsOnService(service, outputs, user.getUserId());
1156 assertNotNull(outputsOnService);
1157 assertSame(service, outputsOnService);
1161 void testCreateOutputsOnService_Fail_whenOutputsIsEmpty() {
1162 Service service = createServiceObject(true);
1163 Map<String, OutputDefinition> outputs = new HashMap<>();
1164 Service outputsOnService = testSubject.createOutputsOnService(service, outputs, user.getUserId());
1165 assertNotNull(outputsOnService);
1166 assertSame(service, outputsOnService);
1170 void testCreateOutputsOnService_Fail_createOutputsInGraph() {
1171 Service service = createServiceObject(true);
1172 List<OutputDefinition> resourceOutputs = new ArrayList<>();
1173 OutputDefinition outputDefinition = new OutputDefinition();
1174 resourceOutputs.add(outputDefinition);
1175 outputDefinition.setName("outputDefinitionName");
1176 service.setOutputs(resourceOutputs);
1177 Map<String, OutputDefinition> outputs = new HashMap<>();
1178 outputs.put("outputsMap", outputDefinition);
1180 when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId()))
1181 .thenReturn(Either.right(new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode())));
1183 final var componentException = assertThrows(ComponentException.class, () -> {
1184 testSubject.createOutputsOnService(service, outputs, user.getUserId());
1186 assertNotNull(componentException);
1187 assertEquals(ActionStatus.OK, componentException.getActionStatus());
1188 assertEquals(400, componentException.getResponseFormat().getStatus());
1192 void testCreateOutputsOnService_Fail_getToscaElement() {
1193 Service service = createServiceObject(true);
1194 List<OutputDefinition> resourceOutputs = new ArrayList<>();
1195 OutputDefinition outputDefinition = new OutputDefinition();
1196 resourceOutputs.add(outputDefinition);
1197 outputDefinition.setName("outputDefinitionName");
1198 service.setOutputs(resourceOutputs);
1199 Map<String, OutputDefinition> outputs = new HashMap<>();
1200 outputs.put("outputsMap", outputDefinition);
1202 when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId())).thenReturn(Either.left(resourceOutputs));
1203 when(toscaOperationFacade.getToscaElement(service.getUniqueId())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1205 final var componentException = assertThrows(ComponentException.class, () -> {
1206 testSubject.createOutputsOnService(service, outputs, user.getUserId());
1208 assertNotNull(componentException);
1209 assertEquals(ActionStatus.OK, componentException.getActionStatus());
1210 assertEquals(400, componentException.getResponseFormat().getStatus());
1214 void testAssociateCINodeFilterToComponent() {
1215 String yamlName = "yamlName.yml";
1216 Service service = createServiceObject(true);
1217 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1218 nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1220 when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1221 .thenReturn(StorageOperationStatus.OK);
1223 testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap);
1224 verify(componentNodeFilterBusinessLogic, times(1)).associateNodeFilterToComponentInstance(service.getUniqueId(),
1229 void testAssociateCINodeFilterToComponentFail() {
1230 String yamlName = "yamlName.yml";
1231 Service service = createServiceObject(true);
1232 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1233 nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1235 when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1236 .thenReturn(StorageOperationStatus.NOT_FOUND);
1238 Assertions.assertThrows(ComponentException.class, () -> testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap));
1242 void testCreateServiceTransaction() {
1243 Service service = createServiceObject(true);
1244 List<ComponentInstance> list = new ArrayList<>();
1245 ComponentInstance componentInstance = new ComponentInstance();
1246 componentInstance.setName("name");
1247 service.setComponentInstances(list);
1248 when(toscaOperationFacade.validateComponentNameExists(
1249 anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class))).thenReturn(Either.left(false));
1251 when(toscaOperationFacade.createToscaComponent(any(Service.class))).thenReturn(Either.left(service));
1253 Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true));
1257 void testCreateArtifactsPlaceHolderData() {
1258 Service service = createServiceObject(true);
1259 CategoryDefinition category = new CategoryDefinition();
1260 category.setName("");
1261 List<CategoryDefinition> categories = new ArrayList<>();
1262 categories.add(category);
1263 service.setCategories(categories);
1264 Assertions.assertNotNull(service);
1266 testSubject.createArtifactsPlaceHolderData(service, user);
1271 void testSetInformationalArtifactsPlaceHolder() {
1272 Service service = createServiceObject(true);
1274 Assertions.assertNotNull(service);
1276 testSubject.setInformationalArtifactsPlaceHolder(service, user);
1281 void testValidateNestedDerivedFromDuringUpdate() {
1282 Resource currentResource = createParseResourceObject(true);
1283 Resource updateInfoResource = createParseResourceObject(true);
1284 String key = "2323456";
1286 List<String> currentDerivedFromList = new ArrayList<>();
1287 currentDerivedFromList.add(key);
1288 currentResource.setDerivedFrom(currentDerivedFromList);
1289 List<String> updatedDerivedFromList = new ArrayList<>();
1290 updatedDerivedFromList.add("23344567778");
1291 updateInfoResource.setDerivedFrom(updatedDerivedFromList);
1293 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1294 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1296 Assertions.assertNotNull(
1297 testSubject.validateNestedDerivedFromDuringUpdate(currentResource, updateInfoResource, true));
1302 void testValidateDerivedFromExtending() {
1303 Resource currentResource = createParseResourceObject(true);
1304 Resource updateInfoResource = createParseResourceObject(true);
1306 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1307 .thenReturn(Either.left(false));
1309 Assertions.assertNotNull(
1310 testSubject.validateDerivedFromExtending(user, currentResource, updateInfoResource,
1311 AuditingActionEnum.IMPORT_RESOURCE));
1316 void testValidateResourceFieldsBeforeUpdate() {
1317 Resource currentResource = createParseResourceObject(true);
1318 Resource updateInfoResource = createParseResourceObject(true);
1320 Assertions.assertNotNull(currentResource);
1322 testSubject.validateResourceFieldsBeforeUpdate(currentResource, updateInfoResource, true, true);
1327 void testValidateResourceName() {
1328 Resource currentResource = createParseResourceObject(true);
1329 Resource updateInfoResource = createParseResourceObject(true);
1330 currentResource.setName("test1");
1331 updateInfoResource.setName("test2");
1333 Assertions.assertThrows(ComponentException.class, () ->
1334 testSubject.validateResourceName(currentResource, updateInfoResource, true, false));
1339 void testIsResourceNameEquals() {
1340 Resource currentResource = createParseResourceObject(true);
1341 Resource updateInfoResource = createParseResourceObject(true);
1343 boolean resourceNameEquals = testSubject.isResourceNameEquals(currentResource, updateInfoResource);
1344 assertTrue(resourceNameEquals);
1348 void testPrepareResourceForUpdate() {
1349 Resource oldResource = createParseResourceObject(true);
1350 Resource newResource = createParseResourceObject(true);
1351 when(lifecycleBusinessLogic.changeState(anyString(), any(User.class), any(LifeCycleTransitionEnum.class),
1352 any(LifecycleChangeInfoWithAction.class), anyBoolean(), anyBoolean())).thenReturn(Either.left(oldResource));
1354 Assertions.assertNotNull(
1355 testSubject.prepareResourceForUpdate(oldResource, newResource, user, true, true));
1360 void testFailOnChangeState() {
1361 ResponseFormat response = new ResponseFormat();
1362 Resource oldResource = createParseResourceObject(true);
1363 oldResource.setUniqueId("123");
1364 Resource newResource = createParseResourceObject(true);
1366 Assertions.assertThrows(ComponentException.class, () ->
1367 testSubject.failOnChangeState(response, user, oldResource, newResource));
1371 void testHandleResourceGenericType() {
1372 Resource resource = createParseResourceObject(true);
1374 Resource resource1 = testSubject.handleResourceGenericType(resource);
1375 assertNotEquals(resource, resource1);
1379 void testUpdateOrCreateGroups() {
1380 Resource resource = createParseResourceObject(true);
1381 Map<String, GroupDefinition> groups = new HashMap<>();
1382 Assertions.assertNotNull(resource);
1384 testSubject.updateOrCreateGroups(resource, groups);
1388 void testAddGroupsToCreateOrUpdate() {
1389 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1390 GroupDefinition groupDefinition = new GroupDefinition();
1391 groupDefinition.setInvariantName("groupDefinitionName");
1392 groupsFromResource.add(groupDefinition);
1393 List<GroupDefinition> groupsAsList = new ArrayList<>();
1394 GroupDefinition groupNewDefinition = getGroupDefinition();
1395 groupsAsList.add(groupNewDefinition);
1396 List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1397 List<GroupDefinition> groupsToCreate = new ArrayList<>();
1398 Assertions.assertNotNull(groupDefinition);
1400 testSubject.addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1404 void testAddGroupsToDelete() {
1405 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1406 GroupDefinition groupDefinition = new GroupDefinition();
1407 groupDefinition.setName("groupDefinitionName");
1408 groupsFromResource.add(groupDefinition);
1409 List<GroupDefinition> groupsAsList = new ArrayList<>();
1410 GroupDefinition groupNewDefinition = new GroupDefinition();
1411 groupNewDefinition.setName("groupNewDefinitionName");
1412 groupsAsList.add(groupNewDefinition);
1413 List<GroupDefinition> groupsToDelete = new ArrayList<>();
1414 Assertions.assertNotNull(groupsFromResource);
1416 testSubject.addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1420 void testUpdateGroupsMembersUsingResource() {
1421 Service component = createServiceObject(true);
1422 Map<String, GroupDefinition> groups = new HashMap<>();
1423 GroupDefinition groupDefinition = getGroupDefinition();
1424 groupDefinition.setMembers(null);
1425 groups.put("groupsMap", groupDefinition);
1427 Assertions.assertNotNull(
1428 testSubject.updateGroupsMembersUsingResource(groups, component));
1432 void testupdateGroupMembers() {
1433 Service component = createServiceObject(true);
1434 Map<String, GroupDefinition> groups = new HashMap<>();
1435 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1436 List<ComponentInstance> componentInstances = new ArrayList<>();
1437 String groupName = "groupName";
1438 Map<String, String> members = new HashMap<>();
1440 Assertions.assertThrows(ComponentException.class, () ->
1441 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1445 void testupdateGroupMembersNotNull() {
1446 Service component = createServiceObject(true);
1447 Map<String, GroupDefinition> groups = getGroups();
1448 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1449 List<ComponentInstance> componentInstances = new ArrayList<>();
1450 ComponentInstance componentInstance = new ComponentInstance();
1451 componentInstance.setName("componentInstanceName");
1452 componentInstance.setUniqueId("componentInstanceUniqueId");
1453 componentInstances.add(componentInstance);
1454 String groupName = "groupName";
1455 Map<String, String> members = new HashMap<>();
1456 members.put("members", "members");
1457 members.put("componentInstanceName", "members");
1459 Assertions.assertThrows(ComponentException.class, () ->
1460 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1464 void testFillResourceMetadataForServiceFailure() {
1465 String yamlName = "yamlName";
1466 Service resourceVf = createServiceObject(true);
1467 String nodeName = "nodeName";
1469 Assertions.assertThrows(ComponentException.class, () ->
1470 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1474 void testFillResourceMetadataForServiceWrongType() {
1475 String yamlName = "yamlName";
1476 Service resourceVf = createServiceObject(true);
1477 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "nodeName";
1479 Assertions.assertThrows(ComponentException.class, () ->
1480 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1484 void testFillResourceMetadataForServiceSuccess() {
1485 String yamlName = "yamlName";
1486 Service resourceVf = createServiceObject(true);
1487 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "VFC";
1489 Assertions.assertNotNull(
1490 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1494 void testpropagateStateToCertified() {
1495 String yamlName = "yamlName";
1496 Resource resource = createParseResourceObject(true);
1497 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1498 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1500 Assertions.assertNotNull(
1501 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1505 void testpropagateStateToCertifiedIsTrue() {
1506 String yamlName = "yamlName";
1507 Resource resource = createParseResourceObject(true);
1508 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1509 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1511 Assertions.assertNotNull(
1512 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1516 void testBuildValidComplexVfc2() {
1517 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1518 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1519 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1520 List<String> derivedFrom = new ArrayList<>();
1521 derivedFrom.add("derivedFrom");
1522 nodeTypeInfo.setDerivedFrom(derivedFrom);
1523 nodesInfo.put(nodeName, nodeTypeInfo);
1525 final CsarInfo csarInfo = getCsarInfo();
1526 Assertions.assertThrows(ComponentException.class, () ->
1527 testSubject.buildValidComplexVfc(csarInfo, nodeName, nodesInfo));
1531 void testUpdateGroupsOnResourceEmptyGroups() {
1532 Resource resource = createParseResourceObject(true);
1533 Map<String, GroupDefinition> groups = new HashMap<>();
1535 Assertions.assertNotNull(
1536 testSubject.updateGroupsOnResource(resource, groups));
1540 void testSetInformationalArtifactsPlaceHolder2() {
1541 Resource resource = createParseResourceObject(true);
1542 List<CategoryDefinition> categoryDefinitions = new ArrayList<>();
1543 CategoryDefinition categoryDefinition = new CategoryDefinition();
1544 categoryDefinition.setName("");
1545 categoryDefinitions.add(categoryDefinition);
1546 resource.setCategories(categoryDefinitions);
1547 Assertions.assertNotNull(resource);
1549 testSubject.setInformationalArtifactsPlaceHolder(resource, user);
1553 void testRollback() {
1554 Resource resource = createParseResourceObject(true);
1555 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1556 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1557 createdArtifacts.add(artifactDefinition);
1558 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1559 nodeTypesNewCreatedArtifacts.add(artifactDefinition);
1560 Assertions.assertNotNull(resource);
1562 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1566 void testRollback_NotNull() {
1567 Resource resource = createParseResourceObject(true);
1568 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1569 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1570 artifactDefinition.setArtifactName("artifactName");
1571 createdArtifacts.add(artifactDefinition);
1572 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1573 ArtifactDefinition artifactDefinition2 = new ArtifactDefinition();
1574 artifactDefinition2.setArtifactChecksum("artifactChecksum");
1575 nodeTypesNewCreatedArtifacts.add(artifactDefinition2);
1576 Assertions.assertNotNull(resource);
1578 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1582 void testCreateArtifactsPlaceHolderData2() {
1583 Resource resource = createParseResourceObject(true);
1585 Assertions.assertNotNull(resource);
1587 testSubject.createArtifactsPlaceHolderData(resource, user);
1591 void testHandleGroupsProperties() {
1592 Service service = createServiceObject(true);
1593 Map<String, GroupDefinition> groups = getGroups();
1594 Assertions.assertNotNull(service);
1596 testSubject.handleGroupsProperties(service, groups);
1600 void testHandleGroupsProperties2() {
1601 Resource resource = createParseResourceObject(true);
1602 Map<String, GroupDefinition> groups = getGroups();
1603 Assertions.assertNotNull(resource);
1605 testSubject.handleGroupsProperties(resource, groups);
1609 void testHandleGetInputs() {
1610 PropertyDataDefinition property = new PropertyDataDefinition();
1611 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1612 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1613 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1614 getInput.setInputId("inputId");
1615 getInput.setInputName("inputName");
1616 getInputValueDataDefinition.setInputName("inputName");
1617 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1618 getInputValueDataDefinition.setGetInputIndex(getInputValueDataDefinition);
1619 getInputValues.add(getInputValueDataDefinition);
1620 property.setGetInputValues(getInputValues);
1621 List<InputDefinition> inputs = new ArrayList<>();
1622 InputDefinition inputDefinition = new InputDefinition();
1623 inputDefinition.setName("inputName");
1624 inputDefinition.setUniqueId("abc12345");
1625 inputs.add(inputDefinition);
1626 Assertions.assertNotNull(inputs);
1628 testSubject.handleGetInputs(property, inputs);
1632 void testHandleGetInputs_null() {
1633 PropertyDataDefinition property = new PropertyDataDefinition();
1634 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1635 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1636 getInputValueDataDefinition.setInputName("inputName");
1637 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1638 getInputValues.add(getInputValueDataDefinition);
1639 property.setGetInputValues(getInputValues);
1640 List<InputDefinition> inputs = new ArrayList<>();
1641 Assertions.assertThrows(NoSuchElementException.class, () ->
1642 testSubject.handleGetInputs(property, inputs));
1646 void testFindInputByName() {
1647 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1648 getInput.setInputId("inputId");
1649 getInput.setInputName("inputName");
1650 List<InputDefinition> inputs = new ArrayList<>();
1651 InputDefinition inputDefinition = new InputDefinition();
1652 inputDefinition.setName("inputName");
1653 inputDefinition.setUniqueId("abc12345");
1654 inputs.add(inputDefinition);
1656 Assertions.assertNotNull(
1657 testSubject.findInputByName(inputs, getInput));
1661 void testAssociateComponentInstancePropertiesToComponent() {
1662 String yamlName = "yamlName";
1663 Resource resource = createParseResourceObject(true);
1664 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1665 Assertions.assertThrows(ComponentException.class, () ->
1666 testSubject.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties));
1670 void testAssociateComponentInstanceInputsToComponent() {
1671 String yamlName = "yamlName";
1672 Resource resource = createParseResourceObject(true);
1673 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1674 List<ComponentInstanceInput> componentInstanceInputList = new ArrayList<>();
1675 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1676 componentInstanceInput.setName("componentInstanceInputName");
1677 componentInstanceInputList.add(componentInstanceInput);
1678 Assertions.assertNotNull(resource);
1680 testSubject.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1684 void testAssociateDeploymentArtifactsToInstances() {
1685 String yamlName = "yamlName";
1686 Resource resource = createParseResourceObject(true);
1687 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1689 Assertions.assertThrows(ComponentException.class, () ->
1690 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1694 void testAssociateArtifactsToInstances() {
1695 String yamlName = "yamlName";
1696 Resource resource = createParseResourceObject(true);
1697 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1699 Assertions.assertThrows(ComponentException.class, () ->
1700 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1704 void testAssociateArtifactsToInstances2() {
1705 String yamlName = "yamlName";
1706 Resource resource = createParseResourceObject(true);
1707 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1709 Assertions.assertThrows(ComponentException.class, () ->
1710 testSubject.associateArtifactsToInstances(yamlName, resource, instDeploymentArtifacts));
1714 void testAssociateOrAddCalculatedCapReq() {
1715 String yamlName = "yamlName";
1716 Resource resource = createParseResourceObject(true);
1717 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1718 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1719 Assertions.assertThrows(ComponentException.class, () ->
1720 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1724 void testAssociateInstAttributeToComponentToInstances() {
1725 String yamlName = "yamlName";
1726 Resource resource = createParseResourceObject(true);
1727 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1728 Assertions.assertThrows(ComponentException.class, () ->
1729 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1733 void testThrowComponentExceptionByResource() {
1734 StorageOperationStatus status = StorageOperationStatus.OK;
1735 Resource resource = createParseResourceObject(true);
1736 Assertions.assertThrows(ComponentException.class, () ->
1737 testSubject.throwComponentExceptionByResource(status, resource));
1741 void testGetResourceAfterCreateRelations() {
1742 Resource resource = createParseResourceObject(true);
1743 Resource newResource = new Resource();
1745 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1746 .thenReturn(Either.left(newResource));
1747 Resource resourceAfterCreateRelations = testSubject.getResourceAfterCreateRelations(resource);
1748 assertNotNull(resourceAfterCreateRelations);
1752 void testSetCapabilityNamesTypes() {
1753 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1754 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1755 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1756 capabilityDefinition.setName("Capability");
1757 capabilityDefinition.setType("Resource");
1758 capabilityDefinitionList.add(capabilityDefinition);
1759 originCapabilities.put("Capability", capabilityDefinitionList);
1760 Map<String, List<UploadCapInfo>> uploadedCapabilities = new HashMap<>();
1761 List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
1762 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1763 uploadCapInfoList.add(uploadCapInfo);
1764 uploadedCapabilities.put("Capability", uploadCapInfoList);
1765 Assertions.assertNotNull(originCapabilities);
1767 testSubject.setCapabilityNamesTypes(originCapabilities, uploadedCapabilities);
1771 void testAssociateComponentInstanceInputsToComponent2() {
1772 String yamlName = "yamlName";
1773 Service service = createServiceObject(true);
1774 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1776 Assertions.assertNotNull(service);
1778 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1782 void testAssociateComponentInstanceInputsNotNullToComponent2() {
1783 String yamlName = "yamlName";
1784 Service service = createServiceObject(true);
1785 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1786 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
1787 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1788 componentInstanceInput.setName("ComponentInstanceInputName");
1789 componentInstanceInputs.add(componentInstanceInput);
1790 instInputs.put("instInputs", componentInstanceInputs);
1791 when(toscaOperationFacade.associateComponentInstanceInputsToComponent(any(Map.class),
1792 anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1793 Assertions.assertThrows(ComponentException.class, () ->
1794 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs));
1798 void testAssociateComponentInstancePropertiesToComponent2() {
1799 String yamlName = "yamlName";
1800 Service service = createServiceObject(true);
1801 Map<String, List<ComponentInstanceProperty>> instInputs = new HashMap<>();
1802 Map<String, List<ComponentInstanceProperty>> instInputMap = new HashMap<>();
1803 when(toscaOperationFacade.associateComponentInstancePropertiesToComponent(any(), anyString()))
1804 .thenReturn(Either.left(instInputMap));
1805 Assertions.assertNotNull(service);
1807 testSubject.associateComponentInstancePropertiesToComponent(yamlName, service, instInputs);
1811 void testAssociateDeploymentArtifactsToInstances2() {
1812 String yamlName = "yamlName";
1813 Service service = createServiceObject(true);
1814 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1816 Assertions.assertThrows(ComponentException.class, () ->
1817 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts));
1821 void testAssociateArtifactsToInstances3() {
1822 String yamlName = "yamlName";
1823 Service service = createServiceObject(true);
1824 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1826 Assertions.assertThrows(ComponentException.class, () ->
1827 testSubject.associateArtifactsToInstances(yamlName, service, instArtifacts));
1831 void testAssociateOrAddCalculatedCapReq2() {
1832 String yamlName = "yamlName";
1833 Service resource = createServiceObject(true);
1834 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1835 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1836 Assertions.assertThrows(ComponentException.class, () ->
1837 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1841 void testAssociateInstAttributeToComponentToInstances2() {
1842 String yamlName = "yamlName";
1843 Service resource = createServiceObject(true);
1844 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1845 Assertions.assertThrows(ComponentException.class, () ->
1846 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1850 void testAssociateRequirementsToService() {
1851 String yamlName = "yamlName";
1852 Service resource = createServiceObject(true);
1853 Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
1854 Assertions.assertThrows(ComponentException.class, () ->
1855 testSubject.associateRequirementsToService(yamlName, resource, requirements));
1859 void testAssociateCapabilitiesToService() {
1860 String yamlName = "yamlName";
1861 Service resource = createServiceObject(true);
1862 Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
1863 Assertions.assertThrows(ComponentException.class, () ->
1864 testSubject.associateCapabilitiesToService(yamlName, resource, capabilities));
1868 void testAssociateResourceInstances() {
1869 String yamlName = "yamlName";
1870 Service resource = createServiceObject(true);
1871 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1872 when(toscaOperationFacade.associateResourceInstances(any(Component.class),
1873 anyString(), any(ArrayList.class))).thenReturn(Either.left(relations));
1874 Assertions.assertNotNull(resource);
1876 testSubject.associateResourceInstances(yamlName, resource, relations);
1880 void testAddCapabilities() {
1881 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1882 String type = "type";
1883 List<CapabilityDefinition> capabilities = new ArrayList<>();
1884 Assertions.assertNotNull(type);
1886 testSubject.addCapabilities(originCapabilities, type, capabilities);
1890 void testAddCapabilitiesProperties() {
1891 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1892 List<UploadCapInfo> capabilities = new ArrayList<>();
1893 UploadCapInfo capability = new UploadCapInfo();
1894 List<UploadPropInfo> properties = new ArrayList<>();
1895 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1896 uploadPropInfo.setName("uploadPropInfoName");
1897 properties.add(uploadPropInfo);
1898 capability.setProperties(properties);
1899 capability.setName("capabilityName");
1900 capabilities.add(capability);
1901 Assertions.assertNotNull(capabilities);
1903 testSubject.addCapabilitiesProperties(newPropertiesMap, capabilities);
1907 void testGetServiceWithGroups() {
1908 String resourceId = "resourceId";
1909 Service service = createServiceObject(true);
1910 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1911 .thenReturn(Either.left(service));
1912 Assertions.assertNotNull(
1913 testSubject.getServiceWithGroups(resourceId));
1917 void testGetResourceWithGroups() {
1918 String resourceId = "resourceId";
1919 Resource resource = createParseResourceObject(false);
1920 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1921 .thenReturn(Either.left(resource));
1922 Assertions.assertNotNull(
1923 testSubject.getResourceWithGroups(resourceId));
1927 void testAssociateResourceInstances2() {
1928 String yamlName = "yamlName";
1929 Resource resource = createParseResourceObject(true);
1930 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1931 when(toscaOperationFacade.associateResourceInstances(any(Resource.class),
1932 anyString(), any(ArrayList.class))).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1933 Assertions.assertThrows(ComponentException.class, () ->
1934 testSubject.associateResourceInstances(yamlName, resource, relations));
1938 void testAddRelationsToRI() {
1939 String yamlName = "group.yml";
1940 Resource resource = createResourceObject(false);
1942 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1943 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1944 nodesInfoValue.getRequirements().get("requirements").get(0).setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1945 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1946 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1947 ComponentInstance componentInstance = new ComponentInstance();
1948 componentInstance.setName("zxjTestImportServiceAb");
1949 componentInstancesList.add(componentInstance);
1950 resource.setComponentInstances(componentInstancesList);
1951 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setLeftOccurrences("1");
1952 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setMaxOccurrences("1");
1953 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setCapability("tosca.capabilities.Node");
1954 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1955 RequirementDefinition requirementDefinition = new RequirementDefinition();
1956 requirementDefinition.setOwnerId("1");
1957 requirementDefinition.setUniqueId("2");
1958 requirementDefinition.setCapability("3");
1959 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1960 capabilityDefinition.setName("4");
1961 capabilityDefinition.setUniqueId("5");
1962 capabilityDefinition.setOwnerId("6");
1963 ResponseFormat responseFormat = new ResponseFormat();
1964 responseFormat.setStatus(200);
1965 Assertions.assertNotNull(resource);
1967 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1971 void testAddRelationsToRI_null() {
1972 String yamlName = "group.yml";
1973 Resource resource = createParseResourceObject(true);
1974 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1975 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1976 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1977 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1978 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1980 Assertions.assertThrows(ComponentException.class, () ->
1981 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList,
1986 void testAddRelationToRI() {
1987 String yamlName = "yamlName";
1988 Resource resource = createParseResourceObject(true);
1989 resource.setComponentInstances(creatComponentInstances());
1990 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1991 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1993 Assertions.assertNotNull(
1994 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1998 void testAddRelationToRI_null() {
1999 String yamlName = "yamlName.yml";
2000 Resource resource = createParseResourceObject(false);
2001 List<ComponentInstance> componentInstancesList = new ArrayList<>();
2002 resource.setComponentInstances(componentInstancesList);
2003 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
2004 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2005 Assertions.assertNotNull(
2006 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
2010 void testFindVfcResource() {
2011 Service service = createServiceObject(true);
2012 String currVfcToscaName = "currVfcToscaName";
2013 String previousVfcToscaName = "previousVfcToscaName";
2014 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
2015 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2016 final CsarInfo csarInfo = getCsarInfo();
2017 Assertions.assertThrows(ComponentException.class, () ->
2018 testSubject.findVfcResource(csarInfo, service, currVfcToscaName, previousVfcToscaName,
2019 StorageOperationStatus.OK));
2022 private GroupDefinition getGroupDefinition() {
2023 GroupDefinition groupDefinition = new GroupDefinition();
2024 Map<String, String> members = new HashMap<>();
2025 members.put("members", "members");
2026 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2027 List<PropertyDataDefinition> properties = new ArrayList<>();
2028 groupDefinition.setInvariantName("groupDefinitionName");
2029 groupDefinition.setMembers(members);
2030 groupDefinition.setProperties(properties);
2031 groupDefinition.setCapabilities(capabilities);
2032 return groupDefinition;
2035 protected Resource createParseResourceObject(boolean afterCreate) {
2036 Resource resource = new Resource();
2037 resource.setName(RESOURCE_NAME);
2038 resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
2039 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
2040 resource.setDescription("My short description");
2041 List<String> tgs = new ArrayList<>();
2043 tgs.add(resource.getName());
2044 resource.setTags(tgs);
2045 List<String> template = new ArrayList<>();
2046 template.add("tosca.nodes.Root");
2047 resource.setDerivedFrom(template);
2048 resource.setVendorName("Motorola");
2049 resource.setVendorRelease("1.0.0");
2050 resource.setContactId("ya5467");
2051 resource.setIcon("defaulticon");
2052 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2053 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2054 requirements.put("test", requirementDefinitionList);
2055 resource.setRequirements(requirements);
2056 resource.setCost("cost");
2057 resource.setResourceVendorModelNumber("02312233");
2059 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2060 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2061 artifacts.put("artifact", artifactDefinition);
2062 resource.setArtifacts(artifacts);
2064 resource.setLicenseType("licType");
2067 resource.setName(resource.getName());
2068 resource.setVersion("0.1");
2069 resource.setUniqueId(resource.getName()
2070 .toLowerCase() + ":" + resource.getVersion());
2071 resource.setCreatorUserId(user.getUserId());
2072 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2073 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2078 protected CsarInfo getCsarInfo() {
2079 String csarUuid = "0010";
2080 User user = new User();
2083 csarFile = new File(
2084 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
2085 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
2087 String vfReousrceName = "resouceName";
2088 String mainTemplateName = "Definitions/service_import_template.yml";
2090 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
2091 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
2092 assertNotNull(mainTemplateService);
2093 final String mainTemplateContent = new String(mainTemplateService);
2095 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false, mock(ModelOperation.class));
2096 } catch (URISyntaxException | ZipException e) {
2102 private String loadFileNameToJsonString(String fileName) throws IOException {
2103 String sourceDir = "src/test/resources/normativeTypes";
2104 return loadFileNameToJsonString(sourceDir, fileName);
2107 private String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
2108 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
2109 byte[] fileContent = Files.readAllBytes(filePath);
2110 return new String(fileContent);
2113 protected Service createServiceObject(boolean afterCreate) {
2114 Service service = new Service();
2115 service.setUniqueId("sid");
2116 service.setName("Service");
2117 CategoryDefinition category = new CategoryDefinition();
2118 category.setName(SERVICE_CATEGORY);
2119 category.setIcons(Collections.singletonList("defaulticon"));
2120 List<CategoryDefinition> categories = new ArrayList<>();
2121 categories.add(category);
2122 service.setCategories(categories);
2123 service.setInstantiationType(INSTANTIATION_TYPE);
2125 service.setDescription("description");
2126 List<String> tgs = new ArrayList<>();
2127 tgs.add(service.getName());
2128 service.setTags(tgs);
2129 service.setIcon("defaulticon");
2130 service.setContactId("aa1234");
2131 service.setProjectCode("12345");
2132 service.setEcompGeneratedNaming(true);
2135 service.setVersion("0.1");
2136 service.setUniqueId(service.getName() + ":" + service.getVersion());
2137 service.setCreatorUserId(user.getUserId());
2138 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2143 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2144 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2145 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2146 assertParseResponse(actualResponse, expectedStatus, variables);
2149 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2150 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2151 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2152 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());