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.mockito.ArgumentMatchers.any;
27 import static org.mockito.ArgumentMatchers.anyBoolean;
28 import static org.mockito.ArgumentMatchers.anyMap;
29 import static org.mockito.ArgumentMatchers.anyString;
30 import static org.mockito.Mockito.mock;
31 import static org.mockito.Mockito.times;
32 import static org.mockito.Mockito.verify;
33 import static org.mockito.Mockito.when;
35 import fj.data.Either;
36 import java.io.IOException;
37 import java.nio.file.FileSystems;
38 import java.nio.file.Files;
39 import java.util.ArrayList;
40 import java.util.Collections;
41 import java.util.EnumMap;
42 import java.util.HashMap;
43 import java.util.List;
45 import java.util.Map.Entry;
46 import java.util.NoSuchElementException;
47 import org.apache.commons.collections.map.HashedMap;
48 import org.apache.commons.lang3.tuple.ImmutablePair;
49 import org.glassfish.grizzly.http.util.HttpStatus;
50 import org.junit.jupiter.api.Assertions;
51 import org.junit.jupiter.api.BeforeEach;
52 import org.junit.jupiter.api.Test;
53 import org.mockito.MockitoAnnotations;
54 import org.openecomp.sdc.ElementOperationMock;
55 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
56 import org.openecomp.sdc.be.components.csar.CsarInfo;
57 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
58 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
59 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
60 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
61 import org.openecomp.sdc.be.dao.api.ActionStatus;
62 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
63 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
64 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
65 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
66 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
67 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
68 import org.openecomp.sdc.be.impl.ComponentsUtils;
69 import org.openecomp.sdc.be.model.ArtifactDefinition;
70 import org.openecomp.sdc.be.model.AttributeDefinition;
71 import org.openecomp.sdc.be.model.CapabilityDefinition;
72 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
73 import org.openecomp.sdc.be.model.Component;
74 import org.openecomp.sdc.be.model.ComponentInstance;
75 import org.openecomp.sdc.be.model.ComponentInstanceInput;
76 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
77 import org.openecomp.sdc.be.model.ComponentParametersView;
78 import org.openecomp.sdc.be.model.GroupDefinition;
79 import org.openecomp.sdc.be.model.InputDefinition;
80 import org.openecomp.sdc.be.model.InterfaceDefinition;
81 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
82 import org.openecomp.sdc.be.model.LifecycleStateEnum;
83 import org.openecomp.sdc.be.model.NodeTypeInfo;
84 import org.openecomp.sdc.be.model.OutputDefinition;
85 import org.openecomp.sdc.be.model.PropertyDefinition;
86 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
87 import org.openecomp.sdc.be.model.RequirementDefinition;
88 import org.openecomp.sdc.be.model.Resource;
89 import org.openecomp.sdc.be.model.Service;
90 import org.openecomp.sdc.be.model.UploadCapInfo;
91 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
92 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
93 import org.openecomp.sdc.be.model.UploadPropInfo;
94 import org.openecomp.sdc.be.model.UploadReqInfo;
95 import org.openecomp.sdc.be.model.User;
96 import org.openecomp.sdc.be.model.category.CategoryDefinition;
97 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
98 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
99 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
100 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
101 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
102 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
103 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
104 import org.openecomp.sdc.be.user.Role;
105 import org.openecomp.sdc.common.api.Constants;
106 import org.openecomp.sdc.exception.ResponseFormat;
108 class ServiceImportParseLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
110 private static final String RESOURCE_NAME = "My-Resource_Name with space";
111 private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
112 private static final String GENERIC_ROOT_NAME = "tosca.nodes.Root";
113 private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF";
114 private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR";
115 private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF";
116 private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
117 private static final String RESOURCE_SUBCATEGORY = "Router";
119 private final ComponentsUtils componentsUtils = new ComponentsUtils(mock(AuditingManager.class));
120 private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
121 private final ServiceBusinessLogic serviceBusinessLogic = mock(ServiceBusinessLogic.class);
122 private final ICapabilityTypeOperation capabilityTypeOperation = mock(ICapabilityTypeOperation.class);
123 private final IElementOperation elementDao = mock(IElementOperation.class);
124 private final IInterfaceLifecycleOperation interfaceTypeOperation = mock(IInterfaceLifecycleOperation.class);
125 private final InputsBusinessLogic inputsBusinessLogic = mock(InputsBusinessLogic.class);
126 private final OutputsBusinessLogic outputsBusinessLogic = mock(OutputsBusinessLogic.class);
127 private final LifecycleBusinessLogic lifecycleBusinessLogic = mock(LifecycleBusinessLogic.class);
128 private final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic = mock(ComponentNodeFilterBusinessLogic.class);
130 private ResponseFormatManager responseManager = null;
131 private User user = null;
132 private ServiceImportParseLogic testSubject;
134 private ServiceImportParseLogic createTestSubject() {
135 return new ServiceImportParseLogic(serviceBusinessLogic, componentsUtils, toscaOperationFacade, lifecycleBusinessLogic, inputsBusinessLogic,
136 null, null, interfaceTypeOperation, capabilityTypeOperation, componentNodeFilterBusinessLogic,
137 groupBusinessLogic, outputsBusinessLogic);
141 public void setup() {
142 MockitoAnnotations.openMocks(this);
145 mockElementDao = new ElementOperationMock();
147 // User data and management
149 user.setUserId("jh0003");
150 user.setFirstName("Jimmi");
151 user.setLastName("Hendrix");
152 user.setRole(Role.ADMIN.name());
153 responseManager = ResponseFormatManager.getInstance();
155 testSubject = createTestSubject();
156 serviceBusinessLogic.setElementDao(elementDao);
160 void testFindNodeTypesArtifactsToHandle() {
161 testSubject = createTestSubject();
162 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
163 final Service service = createServiceObject(false);
164 Assertions.assertNotNull(
165 this.testSubject.findNodeTypesArtifactsToHandle(
166 nodeTypesInfo, getCsarInfo(), service));
171 void testBuildNodeTypeYaml() {
172 Map.Entry<String, Object> nodeNameValue = new Entry<String, Object>() {
174 public String getKey() {
179 public Object getValue() {
184 public Object setValue(Object value) {
188 Map<String, Object> mapToConvert = new HashMap<>();
189 String nodeResourceType = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
191 final CsarInfo csarInfo = getCsarInfo();
192 Assertions.assertThrows(ComponentException.class, () ->
193 testSubject.buildNodeTypeYaml(nodeNameValue, mapToConvert, nodeResourceType, csarInfo));
198 void testFindAddNodeTypeArtifactsToHandle() {
200 Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
201 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
202 String namespace = "namespace";
204 ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
205 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
206 final Service service = createServiceObject(false);
207 Resource resource = new Resource();
208 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
209 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
210 .thenReturn(getCompLatestResult);
212 final CsarInfo csarInfo = getCsarInfo();
213 Assertions.assertThrows(ComponentException.class, () ->
214 testSubject.findAddNodeTypeArtifactsToHandle(csarInfo, nodeTypesArtifactsToHandle, service,
215 extractedVfcsArtifacts, namespace, p1));
220 void testFindAddNodeTypeArtifactsToHandleNotNull() {
222 Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
223 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
224 String namespace = "namespace";
225 List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
226 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
227 artifactDefinition.setArtifactName("artifactDefinitionName");
228 vfcArtifacts.add(artifactDefinition);
229 extractedVfcsArtifacts.put(namespace, vfcArtifacts);
230 ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
231 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
232 final Service service = createServiceObject(false);
233 Resource resource = new Resource();
234 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
235 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
236 .thenReturn(getCompLatestResult);
237 Assertions.assertNotNull(extractedVfcsArtifacts);
238 testSubject.findAddNodeTypeArtifactsToHandle(getCsarInfo(), nodeTypesArtifactsToHandle, service,
239 extractedVfcsArtifacts, namespace, p1);
243 void testHandleAndAddExtractedVfcsArtifacts() {
244 List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
245 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
246 artifactDefinition.setArtifactName("artifactDefinitionName");
247 vfcArtifacts.add(artifactDefinition);
248 List<ArtifactDefinition> artifactsToAdd = new ArrayList<>();
249 ArtifactDefinition artifactDefinitionToAdd = new ArtifactDefinition();
250 artifactDefinitionToAdd.setArtifactName("artifactDefinitionToAddName");
251 artifactsToAdd.add(artifactDefinitionToAdd);
252 Assertions.assertNotNull(vfcArtifacts);
254 testSubject.handleAndAddExtractedVfcsArtifacts(vfcArtifacts, artifactsToAdd);
258 void testFindNodeTypeArtifactsToHandle() {
260 Resource curNodeType = createParseResourceObject(true);
261 List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
263 Assertions.assertNull(
264 testSubject.findNodeTypeArtifactsToHandle(curNodeType, extractedArtifacts));
268 void testCollectExistingArtifacts() {
270 Resource curNodeType = createParseResourceObject(true);
271 Assertions.assertNotNull(
272 testSubject.collectExistingArtifacts(curNodeType));
276 void testPutFoundArtifacts() {
277 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
278 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
279 artifactsToUpload.add(artifactDefinition);
280 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
281 artifactsToUpdate.add(artifactDefinition);
282 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
283 artifactsToDelete.add(artifactDefinition);
284 Assertions.assertNotNull(
285 testSubject.putFoundArtifacts(artifactsToUpload, artifactsToUpdate, artifactsToDelete));
289 void testProcessExistingNodeTypeArtifacts() {
290 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
291 List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
292 extractedArtifacts.add(artifactDefinition);
293 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
294 artifactsToUpload.add(artifactDefinition);
295 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
296 artifactsToUpdate.add(artifactDefinition);
297 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
298 artifactsToDelete.add(artifactDefinition);
299 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
300 existingArtifacts.put("test", artifactDefinition);
301 Assertions.assertThrows(ComponentException.class, () ->
302 testSubject.processExistingNodeTypeArtifacts(extractedArtifacts, artifactsToUpload, artifactsToUpdate,
303 artifactsToDelete, existingArtifacts));
308 void testProcessNodeTypeArtifact() {
309 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
310 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
311 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
312 ArtifactDefinition existingArtifact = new ArtifactDefinition();
313 existingArtifact.setArtifactName("ArtifactName");
314 existingArtifact.setArtifactType("ArtifactType");
315 existingArtifact.setArtifactChecksum("ArtifactChecksum");
316 existingArtifacts.put("existingArtifactMap", existingArtifact);
317 ArtifactDefinition currNewArtifact = new ArtifactDefinition();
318 currNewArtifact.setArtifactName("ArtifactName");
319 currNewArtifact.setArtifactType("ArtifactType");
320 currNewArtifact.setPayload("Payload".getBytes());
321 Assertions.assertNotNull(existingArtifact);
322 testSubject.processNodeTypeArtifact(artifactsToUpload, artifactsToUpdate, existingArtifacts, currNewArtifact);
326 void testUpdateFoundArtifact() {
327 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
328 ArtifactDefinition currNewArtifact = new ArtifactDefinition();
329 currNewArtifact.setArtifactChecksum("090909");
330 currNewArtifact.setPayloadData("data");
331 ArtifactDefinition foundArtifact = new ArtifactDefinition();
332 foundArtifact.setArtifactChecksum("08767");
333 Assertions.assertNotNull(currNewArtifact);
335 testSubject.updateFoundArtifact(artifactsToUpdate, currNewArtifact, foundArtifact);
339 void testIsArtifactDeletionRequired() {
340 String artifactId = "artifactId";
341 byte[] artifactFileBytes = new byte[100];
342 boolean isFromCsar = true;
343 Assertions.assertFalse(testSubject.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar));
347 void testFillGroupsFinalFields() {
348 List<GroupDefinition> groupsAsList = new ArrayList<>();
349 GroupDefinition groupDefinition = new GroupDefinition();
350 groupDefinition.setName("groupDefinitionName");
351 groupsAsList.add(groupDefinition);
352 Assertions.assertNotNull(groupsAsList);
353 testSubject.fillGroupsFinalFields(groupsAsList);
357 void testGetComponentTypeForResponse() {
358 Resource resource = createParseResourceObject(true);
359 Assertions.assertNotNull(
360 testSubject.getComponentTypeForResponse(resource));
364 void testGetComponentTypeForResponseByService() {
365 Service service = createServiceObject(true);
366 Assertions.assertNotNull(
367 testSubject.getComponentTypeForResponse(service));
371 void testBuildValidComplexVfc() {
372 Resource resource = createParseResourceObject(true);
373 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
374 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
375 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
376 List<String> derivedFrom = new ArrayList<>();
377 derivedFrom.add("derivedFrom");
378 nodeTypeInfo.setDerivedFrom(derivedFrom);
379 nodesInfo.put(nodeName, nodeTypeInfo);
380 final CsarInfo csarInfo = getCsarInfo();
381 Assertions.assertThrows(ComponentException.class, () ->
382 testSubject.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo));
387 void testValidateResourceBeforeCreate() {
388 Resource resource = createParseResourceObject(true);
390 testSubject.getServiceBusinessLogic().setElementDao(elementDao);
391 final CsarInfo csarInfo = getCsarInfo();
392 Assertions.assertThrows(ComponentException.class, () ->
393 testSubject.validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, false, csarInfo));
398 void testValidateResourceType() {
399 Resource resource = createParseResourceObject(true);
400 Assertions.assertNotNull(
401 testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
405 void testValidateResourceTypeIsEmpty() {
406 Resource resource = new Resource();
407 resource.setResourceType(null);
408 Assertions.assertNotNull(
409 testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
413 void testValidateLifecycleTypesCreate() {
414 Resource resource = createParseResourceObject(true);
415 Map<String, InterfaceDefinition> mapInterfaces = new HashMap<>();
416 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
417 String uniqueId = "01932342212";
418 interfaceDefinition.setUniqueId(uniqueId);
419 mapInterfaces.put("uniqueId", interfaceDefinition);
420 resource.setInterfaces(mapInterfaces);
421 when(interfaceTypeOperation.getInterface(anyString()))
422 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
423 Assertions.assertNotNull(
424 testSubject.validateLifecycleTypesCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
428 void testValidateCapabilityTypesCreate() {
429 Resource resource = createParseResourceObject(true);
430 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
431 String uniqueId = "18982938994";
432 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
433 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
434 capabilityDefinitionList.add(capabilityDefinition);
435 capabilities.put(uniqueId, capabilityDefinitionList);
436 resource.setCapabilities(capabilities);
437 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
438 thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
439 Assertions.assertNotNull(
440 testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
441 AuditingActionEnum.IMPORT_RESOURCE, true));
446 void testValidateCapabilityTypesCreateWhenHaveCapability() {
447 Resource resource = createParseResourceObject(true);
448 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
449 String uniqueId = "18982938994";
450 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
451 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
452 capabilityDefinitionList.add(capabilityDefinition);
453 capabilities.put(uniqueId, capabilityDefinitionList);
454 resource.setCapabilities(capabilities);
455 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
456 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
457 thenReturn(Either.left(capabilityTypeDefinition));
459 Assertions.assertNotNull(
460 testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
461 AuditingActionEnum.IMPORT_RESOURCE, true));
466 void testValidateCapabilityTypeExists() {
467 Resource resource = createParseResourceObject(true);
468 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
469 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
471 Assertions.assertNotNull(
472 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
473 AuditingActionEnum.IMPORT_RESOURCE,
474 eitherResult, typeEntry, false));
479 void testValidateCapabilityTypeExistsWhenPropertiesIsNull() {
480 Resource resource = createParseResourceObject(true);
481 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
482 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
484 String uniqueId = "0987348532";
485 PropertyDefinition propertyDefinition = new PropertyDefinition();
486 Map<String, PropertyDefinition> properties = new HashMap<>();
487 properties.put(uniqueId, propertyDefinition);
488 capabilityTypeDefinition.setProperties(properties);
490 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
491 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
492 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
493 capabilityDefinitionList.add(capabilityDefinition);
494 capabilities.put(uniqueId, capabilityDefinitionList);
495 resource.setCapabilities(capabilities);
497 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
498 thenReturn(Either.left(capabilityTypeDefinition));
499 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
501 Assertions.assertNotNull(
502 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
503 AuditingActionEnum.IMPORT_RESOURCE,
504 eitherResult, typeEntry, false));
509 void testValidateCapabilityTypeExistsWhenPropertiesNotNull() {
510 Resource resource = createParseResourceObject(true);
511 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
512 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
514 String uniqueId = "0987348532";
515 PropertyDefinition propertyDefinition = new PropertyDefinition();
516 propertyDefinition.setName(uniqueId);
517 Map<String, PropertyDefinition> properties = new HashMap<>();
518 properties.put(uniqueId, propertyDefinition);
519 capabilityTypeDefinition.setProperties(properties);
521 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
523 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
524 List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
525 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
526 componentInstanceProperty.setValueUniqueUid(uniqueId);
527 componentInstanceProperty.setName(uniqueId);
528 componentInstancePropertyList.add(componentInstanceProperty);
529 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
530 capabilityDefinition.setProperties(componentInstancePropertyList);
531 capabilityDefinitionList.add(capabilityDefinition);
533 capabilities.put(uniqueId, capabilityDefinitionList);
534 resource.setCapabilities(capabilities);
536 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
537 thenReturn(Either.left(capabilityTypeDefinition));
538 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
540 Assertions.assertNotNull(
541 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
542 AuditingActionEnum.IMPORT_RESOURCE,
543 eitherResult, typeEntry, false));
548 void testValidateCapabilityTypeExists2() {
549 Resource resource = createParseResourceObject(true);
550 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
551 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
552 thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
554 for (String type : resource.getRequirements().keySet()) {
555 Assertions.assertNotNull(
556 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
557 resource.getRequirements().get(type), AuditingActionEnum.IMPORT_RESOURCE, eitherResult, type,
564 void testValidateResourceFieldsBeforeCreate() {
565 Resource resource = createParseResourceObject(true);
566 Assertions.assertThrows(ComponentException.class, () ->
567 testSubject.validateResourceFieldsBeforeCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
571 void testValidateDerivedFromExist() {
572 Resource resource = createParseResourceObject(true);
573 when(toscaOperationFacade.validateToscaResourceNameExists(anyString())).thenReturn(Either.left(true));
574 Assertions.assertNotNull(resource);
576 testSubject.validateDerivedFromExist(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
580 void testValidateLicenseType() {
581 Resource resource = createParseResourceObject(true);
583 Assertions.assertThrows(ComponentException.class, () ->
584 testSubject.validateLicenseType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
590 void testValidateCost() {
591 Resource resource = createParseResourceObject(true);
592 Assertions.assertThrows(ComponentException.class, () ->
593 testSubject.validateCost(resource));
597 void testValidateResourceVendorModelNumber() {
598 Resource resource = createParseResourceObject(true);
599 Assertions.assertNotNull(resource);
601 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
605 void testValidateResourceVendorModelNumberWrongLen() {
606 Resource resource = createParseResourceObject(true);
607 resource.setResourceVendorModelNumber("000000000011122221111222333444443222556677788778889999998776554332340");
608 Assertions.assertThrows(ComponentException.class, () ->
609 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
613 void testValidateResourceVendorModelNumberWrongValue() {
614 Resource resource = createParseResourceObject(true);
615 resource.setResourceVendorModelNumber("");
616 Assertions.assertNotNull(resource);
618 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
622 void testValidateVendorReleaseName() {
623 Resource resource = createParseResourceObject(true);
624 resource.setVendorRelease("0.1");
625 Assertions.assertNotNull(resource);
627 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
631 void testValidateVendorReleaseNameFailure() {
632 Resource resource = createParseResourceObject(true);
633 resource.setVendorRelease("");
634 Assertions.assertThrows(ComponentException.class, () ->
635 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
640 void testValidateVendorReleaseNameWrongLen() {
641 Resource resource = createParseResourceObject(true);
642 resource.setVendorRelease("000000000011122221111222333444443222556677788778889999998776554332340");
643 Assertions.assertThrows(ComponentException.class, () ->
644 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
649 void testValidateCategory() {
650 Resource resource = createParseResourceObject(true);
651 Assertions.assertThrows(ComponentException.class, () ->
652 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
656 void testValidateEmptyCategory() {
657 Resource resource = createParseResourceObject(true);
658 resource.setCategories(null);
659 Assertions.assertThrows(ComponentException.class, () ->
660 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
665 void testValidateCategorySizeBiggerThan1() {
666 Resource resource = createParseResourceObject(true);
667 List<CategoryDefinition> categories = new ArrayList<>();
668 CategoryDefinition categoryDefinition1 = new CategoryDefinition();
669 CategoryDefinition categoryDefinition2 = new CategoryDefinition();
670 categories.add(categoryDefinition1);
671 categories.add(categoryDefinition2);
673 resource.setCategories(categories);
674 Assertions.assertThrows(ComponentException.class, () ->
675 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
680 void testValidateEmptySubCategory() {
681 Resource resource = createParseResourceObject(true);
682 List<CategoryDefinition> categories = resource.getCategories();
683 CategoryDefinition categoryDefinition = categories.get(0);
684 categoryDefinition.setSubcategories(null);
686 Assertions.assertThrows(ComponentException.class, () ->
687 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
692 void testValidateEmptySubCategorySizeBiggerThan1() {
693 Resource resource = createParseResourceObject(true);
694 List<CategoryDefinition> categories = resource.getCategories();
695 CategoryDefinition categoryDefinition = categories.get(0);
696 List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
697 SubCategoryDefinition subCategoryDefinition1 = new SubCategoryDefinition();
698 SubCategoryDefinition subCategoryDefinition2 = new SubCategoryDefinition();
699 subcategories.add(subCategoryDefinition1);
700 subcategories.add(subCategoryDefinition2);
702 Assertions.assertThrows(ComponentException.class, () ->
703 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
708 void testValidateEmptyCategoryName() {
709 Resource resource = createParseResourceObject(true);
710 List<CategoryDefinition> categories = resource.getCategories();
711 CategoryDefinition categoryDefinition = categories.get(0);
712 categoryDefinition.setName(null);
714 Assertions.assertThrows(ComponentException.class, () ->
715 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
719 void testValidateEmptySubCategoryName() {
720 Resource resource = createParseResourceObject(true);
721 List<CategoryDefinition> categories = resource.getCategories();
722 CategoryDefinition categoryDefinition = categories.get(0);
723 List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
724 SubCategoryDefinition subCategoryDefinition1 = subcategories.get(0);
725 subCategoryDefinition1.setName(null);
727 Assertions.assertThrows(ComponentException.class, () ->
728 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
732 void testValidateCategoryListed() {
733 Resource resource = createParseResourceObject(true);
734 CategoryDefinition category = resource.getCategories().get(0);
735 SubCategoryDefinition subcategory = category.getSubcategories().get(0);
736 Assertions.assertThrows(ComponentException.class, () ->
737 testSubject.validateCategoryListed(category, subcategory, user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
741 void testFailOnInvalidCategory() {
742 Resource resource = createParseResourceObject(true);
743 Assertions.assertThrows(ComponentException.class, () ->
744 testSubject.failOnInvalidCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
749 void testValidateVendorName() {
750 Resource resource = createParseResourceObject(true);
751 Assertions.assertNotNull(resource);
752 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
756 void testValidateVendorNameEmpty() {
757 Resource resource = createParseResourceObject(true);
758 resource.setVendorName(null);
759 Assertions.assertThrows(ComponentException.class, () ->
760 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
764 void testValidateVendorNameWrongLen() {
765 Resource resource = createParseResourceObject(true);
766 resource.setVendorName("000000000011122221111222333444443222556677788778889999998776554332340");
767 Assertions.assertThrows(ComponentException.class, () ->
768 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
772 void testValidateVendorName2() {
773 Resource resource = createParseResourceObject(true);
774 CategoryDefinition category = resource.getCategories().get(0);
775 SubCategoryDefinition subcategory = category.getSubcategories().get(0);
776 String vendorName = "vendorName";
777 Assertions.assertNotNull(resource);
779 testSubject.validateVendorName(vendorName, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
783 void testFillResourceMetadata2() {
784 String yamlName = "yamlName";
785 Resource resourceVf = createParseResourceObject(true);
786 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
787 resourceVf.setSystemName("systemName");
788 Assertions.assertThrows(ComponentException.class, () ->
789 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
793 void testFillResourceMetadataWrongStart() {
794 String yamlName = "yamlName";
795 Resource resourceVf = createParseResourceObject(true);
796 String nodeName = "WrongStart" + "test";
797 Assertions.assertThrows(ComponentException.class, () ->
798 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
802 void testFillResourceMetadataResourceTypeIsAbs() {
803 String yamlName = "yamlName";
804 Resource resourceVf = createParseResourceObject(true);
805 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + Constants.ABSTRACT;
806 Assertions.assertNotNull(
807 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
811 void testGetNodeTypeActualName() {
812 String fullName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
813 Assertions.assertNotNull(
814 testSubject.getNodeTypeActualName(fullName));
818 void testAddInput() {
819 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
820 InputDefinition prop = new InputDefinition();
821 Assertions.assertNotNull(currPropertiesMap);
823 testSubject.addInput(currPropertiesMap, prop);
827 void testFindAviableRequirement() {
828 String uniqueId = "101929382910";
829 String regName = uniqueId;
830 String yamlName = uniqueId;
831 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
832 ComponentInstance currentCompInstance = new ComponentInstance();
834 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
835 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
836 RequirementDefinition requirementDefinition = new RequirementDefinition();
837 requirementDefinition.setName(uniqueId);
838 requirementDefinition.setMaxOccurrences("10");
839 requirementDefinition.setLeftOccurrences("3");
840 requirementDefinitionList.add(requirementDefinition);
841 requirements.put(uniqueId, requirementDefinitionList);
842 currentCompInstance.setRequirements(requirements);
844 String capName = "capName";
846 Assertions.assertNotNull(
847 testSubject.findAvailableRequirement(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
851 void testFindAviableRequirementSameCapName() {
852 String uniqueId = "101929382910";
853 String regName = uniqueId;
854 String yamlName = uniqueId;
855 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
856 ComponentInstance currentCompInstance = new ComponentInstance();
858 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
859 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
860 RequirementDefinition requirementDefinition = new RequirementDefinition();
861 requirementDefinition.setName(uniqueId);
862 requirementDefinition.setMaxOccurrences("10");
863 requirementDefinition.setLeftOccurrences("3");
864 requirementDefinitionList.add(requirementDefinition);
865 requirements.put(uniqueId, requirementDefinitionList);
866 currentCompInstance.setRequirements(requirements);
868 String capName = uniqueId;
869 Assertions.assertNotNull(
870 testSubject.findAvailableRequirement(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
874 void testFindAvailableCapabilityByTypeOrName() {
875 RequirementDefinition validReq = new RequirementDefinition();
876 ComponentInstance currentCapCompInstance = new ComponentInstance();
877 UploadReqInfo uploadReqInfo = new UploadReqInfo();
879 Assertions.assertThrows(ComponentException.class, () ->
880 testSubject.findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadReqInfo));
884 void testFindAvailableCapability() {
885 String uniqueId = "23422345677";
886 RequirementDefinition validReq = new RequirementDefinition();
887 validReq.setCapability(uniqueId);
888 ComponentInstance instance = new ComponentInstance();
889 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
890 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
891 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
892 capabilityDefinition.setMaxOccurrences("3");
893 capabilityDefinition.setLeftOccurrences("2");
894 capabilityDefinitionList.add(capabilityDefinition);
895 capabilityMap.put(uniqueId, capabilityDefinitionList);
896 instance.setCapabilities(capabilityMap);
898 Assertions.assertNotNull(
899 testSubject.findAvailableCapability(validReq, instance));
903 void testfindAvailableCapability2() {
904 String uniqueId = "23422345677";
905 RequirementDefinition validReq = new RequirementDefinition();
906 validReq.setCapability(uniqueId);
907 ComponentInstance instance = new ComponentInstance();
908 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
909 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
910 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
911 capabilityDefinition.setName(uniqueId);
912 capabilityDefinition.setMaxOccurrences("3");
913 capabilityDefinition.setLeftOccurrences("2");
914 capabilityDefinitionList.add(capabilityDefinition);
915 capabilityMap.put(uniqueId, capabilityDefinitionList);
916 instance.setCapabilities(capabilityMap);
917 UploadReqInfo uploadReqInfo = new UploadReqInfo();
918 uploadReqInfo.setCapabilityName(uniqueId);
920 Assertions.assertNotNull(
921 testSubject.findAvailableCapability(validReq, instance, uploadReqInfo));
925 void testGetComponentWithInstancesFilter() {
927 Assertions.assertNotNull(
928 testSubject.getComponentWithInstancesFilter());
932 void testCreateParseResourceObject() {
933 String key = "0923928394";
934 List<UploadCapInfo> capabilities = new ArrayList<>();
935 UploadCapInfo uploadCapInfo = new UploadCapInfo();
936 uploadCapInfo.setType(key);
937 capabilities.add(uploadCapInfo);
939 String resourceId = "resourceId";
940 Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
941 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
942 capabilityDefinition.setName(key);
943 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
944 capabilityDefinitionList.add(capabilityDefinition);
945 defaultCapabilities.put(key, capabilityDefinitionList);
947 Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
948 InputDefinition prop = new InputDefinition();
950 Resource resource = createParseResourceObject(true);
951 Map<String, List<CapabilityDefinition>> capabilitiesMap = resource.getCapabilities();
952 capabilitiesMap.put(key, capabilityDefinitionList);
954 when(toscaOperationFacade.getToscaFullElement(anyString()))
955 .thenReturn(Either.left(resource));
957 Assertions.assertNotNull(resource);
959 testSubject.addValidComponentInstanceCapabilities(key, capabilities, resourceId, defaultCapabilities,
960 validCapabilitiesMap);
964 void testGetCapabilityFailure() {
965 String resourceId = "resourceId";
966 String key = "0923928394";
967 Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
968 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
969 capabilityDefinition.setName(key);
970 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
971 capabilityDefinitionList.add(capabilityDefinition);
972 defaultCapabilities.put(key, capabilityDefinitionList);
973 String capabilityType = key;
974 when(toscaOperationFacade.getToscaFullElement(anyString()))
975 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
976 Assertions.assertThrows(ComponentException.class, () ->
977 testSubject.getCapability(resourceId, defaultCapabilities, capabilityType));
981 void testValidateCapabilityProperties() {
982 List<UploadCapInfo> capabilities = new ArrayList<>();
983 UploadCapInfo uploadCapInfo = new UploadCapInfo();
984 List<UploadPropInfo> properties = new ArrayList<>();
985 UploadPropInfo uploadPropInfo = new UploadPropInfo();
986 properties.add(uploadPropInfo);
987 uploadCapInfo.setProperties(properties);
988 capabilities.add(uploadCapInfo);
989 String resourceId = "resourceId";
990 CapabilityDefinition defaultCapability = new CapabilityDefinition();
991 defaultCapability.setProperties(null);
992 defaultCapability.setName("test");
994 Assertions.assertThrows(ComponentException.class, () ->
995 testSubject.validateCapabilityProperties(capabilities, resourceId, defaultCapability));
999 void testValidateUniquenessUpdateUploadedComponentInstanceCapability() {
1000 String key = "02124568";
1001 List<UploadCapInfo> capabilities = new ArrayList<>();
1002 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1003 List<UploadPropInfo> properties = new ArrayList<>();
1004 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1005 uploadPropInfo.setName(key);
1006 properties.add(uploadPropInfo);
1007 uploadCapInfo.setProperties(properties);
1008 capabilities.add(uploadCapInfo);
1009 String resourceId = "resourceId";
1010 CapabilityDefinition defaultCapability = new CapabilityDefinition();
1011 List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
1012 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
1013 componentInstancePropertyList.add(componentInstanceProperty);
1014 defaultCapability.setProperties(componentInstancePropertyList);
1015 defaultCapability.setName(key);
1017 Assertions.assertNotNull(defaultCapability);
1019 testSubject.validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, uploadCapInfo);
1023 void testSetDeploymentArtifactsPlaceHolderByResource() {
1024 Resource resource = createParseResourceObject(true);
1026 Assertions.assertNotNull(resource);
1028 testSubject.setDeploymentArtifactsPlaceHolder(resource, user);
1032 void testSetDeploymentArtifactsPlaceHolderByService() {
1033 Service Service = createServiceObject(true);
1035 Assertions.assertNotNull(Service);
1037 testSubject.setDeploymentArtifactsPlaceHolder(Service, user);
1041 void testProcessDeploymentResourceArtifacts() {
1042 Resource resource = createParseResourceObject(true);
1043 resource.setResourceType(ResourceTypeEnum.VF);
1044 Map<String, ArtifactDefinition> artifactMap = new HashMap<>();
1046 Object v = new Object();
1047 Map<String, List<String>> artifactDetails = new HashMap<>();
1048 List<String> artifactTypes = new ArrayList<>();
1049 artifactTypes.add(ResourceTypeEnum.VF.name());
1050 artifactDetails.put("validForResourceTypes", artifactTypes);
1051 v = artifactDetails;
1052 Assertions.assertNotNull(resource);
1054 testSubject.processDeploymentResourceArtifacts(user, resource, artifactMap, k, v);
1058 void testMergeOldResourceMetadataWithNew() {
1059 Resource oldResource = createParseResourceObject(true);
1060 Resource newResource = new Resource();
1062 Assertions.assertNotNull(oldResource);
1064 testSubject.mergeOldResourceMetadataWithNew(oldResource, newResource);
1068 void testBuildComplexVfcMetadata() {
1069 Resource resource = createParseResourceObject(true);
1070 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1071 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1072 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1073 List<String> derivedFrom = new ArrayList<>();
1074 derivedFrom.add("derivedFrom");
1075 nodeTypeInfo.setDerivedFrom(derivedFrom);
1076 nodesInfo.put(nodeName, nodeTypeInfo);
1078 Assertions.assertNotNull(
1079 testSubject.buildComplexVfcMetadata(getCsarInfo(), nodeName, nodesInfo));
1083 void testValidateResourceCreationFromNodeType() {
1084 Resource resource = createParseResourceObject(true);
1085 resource.setDerivedFrom(null);
1086 Assertions.assertThrows(ComponentException.class, () ->
1087 testSubject.validateResourceCreationFromNodeType(resource, user));
1091 void testCreateInputsOnResource() {
1092 Resource resource = createParseResourceObject(true);
1093 Map<String, InputDefinition> inputs = new HashMap<>();
1095 Assertions.assertNotNull(
1096 testSubject.createInputsOnResource(resource, inputs));
1100 void testCreateInputsOnResourceWhenIsNotEmpty() {
1101 String key = "12345667";
1102 Resource resource = createParseResourceObject(true);
1103 List<InputDefinition> inputDefinitionList = new ArrayList<>();
1104 InputDefinition inputDefinition = new InputDefinition();
1105 inputDefinitionList.add(inputDefinition);
1106 resource.setInputs(inputDefinitionList);
1107 Map<String, InputDefinition> inputs = new HashMap<>();
1108 inputs.put(key, inputDefinition);
1109 when(inputsBusinessLogic.createInputsInGraph(anyMap(),
1110 any(Component.class))).thenReturn(Either.left(inputDefinitionList));
1111 when(toscaOperationFacade
1112 .getToscaElement(anyString())).thenReturn(Either.left(resource));
1113 Assertions.assertNotNull(
1114 testSubject.createInputsOnResource(resource, inputs));
1118 void testCreateInputsOnService() {
1119 Service service = createServiceObject(true);
1120 List<InputDefinition> resourceProperties = new ArrayList<>();
1121 InputDefinition inputDefinition = new InputDefinition();
1122 inputDefinition.setName("inputDefinitionName");
1123 service.setInputs(resourceProperties);
1124 Map<String, InputDefinition> inputs = new HashMap<>();
1125 InputDefinition inputDefinitionMap = new InputDefinition();
1126 inputDefinition.setName("inputDefinitionName");
1127 inputs.put("inputsMap", inputDefinitionMap);
1128 List<InputDefinition> inputDefinitionList = new ArrayList<>();
1129 Service newService = new Service();
1131 when(inputsBusinessLogic.createInputsInGraph(any(Map.class), any(Component.class)))
1132 .thenReturn(Either.left(inputDefinitionList));
1133 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
1134 Service inputsOnService = testSubject.createInputsOnService(service, inputs);
1135 assertNotNull(inputsOnService);
1139 void testCreateOutputsOnService_OK() {
1140 Service service = createServiceObject(true);
1141 List<OutputDefinition> resourceOutputs = new ArrayList<>();
1142 OutputDefinition outputDefinition = new OutputDefinition();
1143 resourceOutputs.add(outputDefinition);
1144 outputDefinition.setName("outputDefinitionName");
1145 service.setOutputs(resourceOutputs);
1146 Map<String, OutputDefinition> outputs = new HashMap<>();
1147 outputs.put("outputsMap", outputDefinition);
1149 when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId())).thenReturn(Either.left(resourceOutputs));
1150 when(toscaOperationFacade.getToscaElement(service.getUniqueId())).thenReturn(Either.left(service));
1151 Service outputsOnService = testSubject.createOutputsOnService(service, outputs, user.getUserId());
1152 assertNotNull(outputsOnService);
1153 assertSame(service, outputsOnService);
1157 void testCreateOutputsOnService_Fail_whenOutputsIsEmpty() {
1158 Service service = createServiceObject(true);
1159 Map<String, OutputDefinition> outputs = new HashMap<>();
1160 Service outputsOnService = testSubject.createOutputsOnService(service, outputs, user.getUserId());
1161 assertNotNull(outputsOnService);
1162 assertSame(service, outputsOnService);
1166 void testCreateOutputsOnService_Fail_createOutputsInGraph() {
1167 Service service = createServiceObject(true);
1168 List<OutputDefinition> resourceOutputs = new ArrayList<>();
1169 OutputDefinition outputDefinition = new OutputDefinition();
1170 resourceOutputs.add(outputDefinition);
1171 outputDefinition.setName("outputDefinitionName");
1172 service.setOutputs(resourceOutputs);
1173 Map<String, OutputDefinition> outputs = new HashMap<>();
1174 outputs.put("outputsMap", outputDefinition);
1176 when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId()))
1177 .thenReturn(Either.right(new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode())));
1179 final var componentException = assertThrows(ComponentException.class, () -> {
1180 testSubject.createOutputsOnService(service, outputs, user.getUserId());
1182 assertNotNull(componentException);
1183 assertEquals(ActionStatus.OK, componentException.getActionStatus());
1184 assertEquals(400, componentException.getResponseFormat().getStatus());
1188 void testCreateOutputsOnService_Fail_getToscaElement() {
1189 Service service = createServiceObject(true);
1190 List<OutputDefinition> resourceOutputs = new ArrayList<>();
1191 OutputDefinition outputDefinition = new OutputDefinition();
1192 resourceOutputs.add(outputDefinition);
1193 outputDefinition.setName("outputDefinitionName");
1194 service.setOutputs(resourceOutputs);
1195 Map<String, OutputDefinition> outputs = new HashMap<>();
1196 outputs.put("outputsMap", outputDefinition);
1198 when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId())).thenReturn(Either.left(resourceOutputs));
1199 when(toscaOperationFacade.getToscaElement(service.getUniqueId())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1201 final var componentException = assertThrows(ComponentException.class, () -> {
1202 testSubject.createOutputsOnService(service, outputs, user.getUserId());
1204 assertNotNull(componentException);
1205 assertEquals(ActionStatus.OK, componentException.getActionStatus());
1206 assertEquals(400, componentException.getResponseFormat().getStatus());
1210 void testAssociateCINodeFilterToComponent() {
1211 String yamlName = "yamlName.yml";
1212 Service service = createServiceObject(true);
1213 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1214 nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1216 when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1217 .thenReturn(StorageOperationStatus.OK);
1219 testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap);
1220 verify(componentNodeFilterBusinessLogic, times(1)).associateNodeFilterToComponentInstance(service.getUniqueId(),
1225 void testAssociateCINodeFilterToComponentFail() {
1226 String yamlName = "yamlName.yml";
1227 Service service = createServiceObject(true);
1228 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1229 nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1231 when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1232 .thenReturn(StorageOperationStatus.NOT_FOUND);
1234 Assertions.assertThrows(ComponentException.class, () -> testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap));
1238 void testCreateServiceTransaction() {
1239 Service service = createServiceObject(true);
1240 List<ComponentInstance> list = new ArrayList<>();
1241 ComponentInstance componentInstance = new ComponentInstance();
1242 componentInstance.setName("name");
1243 service.setComponentInstances(list);
1244 when(toscaOperationFacade.validateComponentNameExists(
1245 anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class))).thenReturn(Either.left(false));
1247 when(toscaOperationFacade.createToscaComponent(any(Service.class))).thenReturn(Either.left(service));
1249 Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true));
1253 void testCreateArtifactsPlaceHolderData() {
1254 Service service = createServiceObject(true);
1255 CategoryDefinition category = new CategoryDefinition();
1256 category.setName("");
1257 List<CategoryDefinition> categories = new ArrayList<>();
1258 categories.add(category);
1259 service.setCategories(categories);
1260 Assertions.assertNotNull(service);
1262 testSubject.createArtifactsPlaceHolderData(service, user);
1267 void testSetInformationalArtifactsPlaceHolder() {
1268 Service service = createServiceObject(true);
1270 Assertions.assertNotNull(service);
1272 testSubject.setInformationalArtifactsPlaceHolder(service, user);
1277 void testValidateNestedDerivedFromDuringUpdate() {
1278 Resource currentResource = createParseResourceObject(true);
1279 Resource updateInfoResource = createParseResourceObject(true);
1280 String key = "2323456";
1282 List<String> currentDerivedFromList = new ArrayList<>();
1283 currentDerivedFromList.add(key);
1284 currentResource.setDerivedFrom(currentDerivedFromList);
1285 List<String> updatedDerivedFromList = new ArrayList<>();
1286 updatedDerivedFromList.add("23344567778");
1287 updateInfoResource.setDerivedFrom(updatedDerivedFromList);
1289 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1290 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1292 Assertions.assertNotNull(
1293 testSubject.validateNestedDerivedFromDuringUpdate(currentResource, updateInfoResource, true));
1298 void testValidateDerivedFromExtending() {
1299 Resource currentResource = createParseResourceObject(true);
1300 Resource updateInfoResource = createParseResourceObject(true);
1302 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1303 .thenReturn(Either.left(false));
1305 Assertions.assertNotNull(
1306 testSubject.validateDerivedFromExtending(user, currentResource, updateInfoResource,
1307 AuditingActionEnum.IMPORT_RESOURCE));
1312 void testValidateResourceFieldsBeforeUpdate() {
1313 Resource currentResource = createParseResourceObject(true);
1314 Resource updateInfoResource = createParseResourceObject(true);
1316 Assertions.assertNotNull(currentResource);
1318 testSubject.validateResourceFieldsBeforeUpdate(currentResource, updateInfoResource, true, true);
1323 void testValidateResourceName() {
1324 Resource currentResource = createParseResourceObject(true);
1325 Resource updateInfoResource = createParseResourceObject(true);
1326 currentResource.setName("test1");
1327 updateInfoResource.setName("test2");
1329 Assertions.assertThrows(ComponentException.class, () ->
1330 testSubject.validateResourceName(currentResource, updateInfoResource, true, false));
1335 void testIsResourceNameEquals() {
1336 Resource currentResource = createParseResourceObject(true);
1337 Resource updateInfoResource = createParseResourceObject(true);
1339 boolean resourceNameEquals = testSubject.isResourceNameEquals(currentResource, updateInfoResource);
1340 assertTrue(resourceNameEquals);
1344 void testPrepareResourceForUpdate() {
1345 Resource oldResource = createParseResourceObject(true);
1346 Resource newResource = createParseResourceObject(true);
1347 when(lifecycleBusinessLogic.changeState(anyString(), any(User.class), any(LifeCycleTransitionEnum.class),
1348 any(LifecycleChangeInfoWithAction.class), anyBoolean(), anyBoolean())).thenReturn(Either.left(oldResource));
1350 Assertions.assertNotNull(
1351 testSubject.prepareResourceForUpdate(oldResource, newResource, user, true, true));
1356 void testFailOnChangeState() {
1357 ResponseFormat response = new ResponseFormat();
1358 Resource oldResource = createParseResourceObject(true);
1359 oldResource.setUniqueId("123");
1360 Resource newResource = createParseResourceObject(true);
1362 Assertions.assertThrows(ComponentException.class, () ->
1363 testSubject.failOnChangeState(response, user, oldResource, newResource));
1367 void testHandleResourceGenericType() {
1368 Resource resource = createParseResourceObject(true);
1370 Resource resource1 = testSubject.handleResourceGenericType(resource);
1371 assertNotEquals(resource, resource1);
1375 void testUpdateOrCreateGroups() {
1376 Resource resource = createParseResourceObject(true);
1377 Map<String, GroupDefinition> groups = new HashMap<>();
1378 Assertions.assertNotNull(resource);
1380 testSubject.updateOrCreateGroups(resource, groups);
1384 void testAddGroupsToCreateOrUpdate() {
1385 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1386 GroupDefinition groupDefinition = new GroupDefinition();
1387 groupDefinition.setInvariantName("groupDefinitionName");
1388 groupsFromResource.add(groupDefinition);
1389 List<GroupDefinition> groupsAsList = new ArrayList<>();
1390 GroupDefinition groupNewDefinition = getGroupDefinition();
1391 groupsAsList.add(groupNewDefinition);
1392 List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1393 List<GroupDefinition> groupsToCreate = new ArrayList<>();
1394 Assertions.assertNotNull(groupDefinition);
1396 testSubject.addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1400 void testAddGroupsToDelete() {
1401 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1402 GroupDefinition groupDefinition = new GroupDefinition();
1403 groupDefinition.setName("groupDefinitionName");
1404 groupsFromResource.add(groupDefinition);
1405 List<GroupDefinition> groupsAsList = new ArrayList<>();
1406 GroupDefinition groupNewDefinition = new GroupDefinition();
1407 groupNewDefinition.setName("groupNewDefinitionName");
1408 groupsAsList.add(groupNewDefinition);
1409 List<GroupDefinition> groupsToDelete = new ArrayList<>();
1410 Assertions.assertNotNull(groupsFromResource);
1412 testSubject.addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1416 void testUpdateGroupsMembersUsingResource() {
1417 Service component = createServiceObject(true);
1418 Map<String, GroupDefinition> groups = new HashMap<>();
1419 GroupDefinition groupDefinition = getGroupDefinition();
1420 groupDefinition.setMembers(null);
1421 groups.put("groupsMap", groupDefinition);
1423 Assertions.assertNotNull(
1424 testSubject.updateGroupsMembersUsingResource(groups, component));
1428 void testupdateGroupMembers() {
1429 Service component = createServiceObject(true);
1430 Map<String, GroupDefinition> groups = new HashMap<>();
1431 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1432 List<ComponentInstance> componentInstances = new ArrayList<>();
1433 String groupName = "groupName";
1434 Map<String, String> members = new HashMap<>();
1436 Assertions.assertThrows(ComponentException.class, () ->
1437 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1441 void testupdateGroupMembersNotNull() {
1442 Service component = createServiceObject(true);
1443 Map<String, GroupDefinition> groups = getGroups();
1444 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1445 List<ComponentInstance> componentInstances = new ArrayList<>();
1446 ComponentInstance componentInstance = new ComponentInstance();
1447 componentInstance.setName("componentInstanceName");
1448 componentInstance.setUniqueId("componentInstanceUniqueId");
1449 componentInstances.add(componentInstance);
1450 String groupName = "groupName";
1451 Map<String, String> members = new HashMap<>();
1452 members.put("members", "members");
1453 members.put("componentInstanceName", "members");
1455 Assertions.assertThrows(ComponentException.class, () ->
1456 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1460 void testFillResourceMetadataForServiceFailure() {
1461 String yamlName = "yamlName";
1462 Service resourceVf = createServiceObject(true);
1463 String nodeName = "nodeName";
1465 Assertions.assertThrows(ComponentException.class, () ->
1466 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1470 void testFillResourceMetadataForServiceWrongType() {
1471 String yamlName = "yamlName";
1472 Service resourceVf = createServiceObject(true);
1473 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "nodeName";
1475 Assertions.assertThrows(ComponentException.class, () ->
1476 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1480 void testFillResourceMetadataForServiceSuccess() {
1481 String yamlName = "yamlName";
1482 Service resourceVf = createServiceObject(true);
1483 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "VFC";
1485 Assertions.assertNotNull(
1486 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1490 void testpropagateStateToCertified() {
1491 String yamlName = "yamlName";
1492 Resource resource = createParseResourceObject(true);
1493 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1494 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1496 Assertions.assertNotNull(
1497 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1501 void testpropagateStateToCertifiedIsTrue() {
1502 String yamlName = "yamlName";
1503 Resource resource = createParseResourceObject(true);
1504 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1505 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1507 Assertions.assertNotNull(
1508 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1512 void testBuildValidComplexVfc2() {
1513 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1514 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1515 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1516 List<String> derivedFrom = new ArrayList<>();
1517 derivedFrom.add("derivedFrom");
1518 nodeTypeInfo.setDerivedFrom(derivedFrom);
1519 nodesInfo.put(nodeName, nodeTypeInfo);
1521 final CsarInfo csarInfo = getCsarInfo();
1522 Assertions.assertThrows(ComponentException.class, () ->
1523 testSubject.buildValidComplexVfc(csarInfo, nodeName, nodesInfo));
1527 void testUpdateGroupsOnResourceEmptyGroups() {
1528 Resource resource = createParseResourceObject(true);
1529 Map<String, GroupDefinition> groups = new HashMap<>();
1531 Assertions.assertNotNull(
1532 testSubject.updateGroupsOnResource(resource, groups));
1536 void testSetInformationalArtifactsPlaceHolder2() {
1537 Resource resource = createParseResourceObject(true);
1538 List<CategoryDefinition> categoryDefinitions = new ArrayList<>();
1539 CategoryDefinition categoryDefinition = new CategoryDefinition();
1540 categoryDefinition.setName("");
1541 categoryDefinitions.add(categoryDefinition);
1542 resource.setCategories(categoryDefinitions);
1543 Assertions.assertNotNull(resource);
1545 testSubject.setInformationalArtifactsPlaceHolder(resource, user);
1549 void testRollback() {
1550 Resource resource = createParseResourceObject(true);
1551 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1552 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1553 createdArtifacts.add(artifactDefinition);
1554 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1555 nodeTypesNewCreatedArtifacts.add(artifactDefinition);
1556 Assertions.assertNotNull(resource);
1558 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1562 void testRollback_NotNull() {
1563 Resource resource = createParseResourceObject(true);
1564 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1565 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1566 artifactDefinition.setArtifactName("artifactName");
1567 createdArtifacts.add(artifactDefinition);
1568 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1569 ArtifactDefinition artifactDefinition2 = new ArtifactDefinition();
1570 artifactDefinition2.setArtifactChecksum("artifactChecksum");
1571 nodeTypesNewCreatedArtifacts.add(artifactDefinition2);
1572 Assertions.assertNotNull(resource);
1574 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1578 void testCreateArtifactsPlaceHolderData2() {
1579 Resource resource = createParseResourceObject(true);
1581 Assertions.assertNotNull(resource);
1583 testSubject.createArtifactsPlaceHolderData(resource, user);
1587 void testHandleGroupsProperties() {
1588 Service service = createServiceObject(true);
1589 Map<String, GroupDefinition> groups = getGroups();
1590 Assertions.assertNotNull(service);
1592 testSubject.handleGroupsProperties(service, groups);
1596 void testHandleGroupsProperties2() {
1597 Resource resource = createParseResourceObject(true);
1598 Map<String, GroupDefinition> groups = getGroups();
1599 Assertions.assertNotNull(resource);
1601 testSubject.handleGroupsProperties(resource, groups);
1605 void testHandleGetInputs() {
1606 PropertyDataDefinition property = new PropertyDataDefinition();
1607 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1608 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1609 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1610 getInput.setInputId("inputId");
1611 getInput.setInputName("inputName");
1612 getInputValueDataDefinition.setInputName("inputName");
1613 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1614 getInputValueDataDefinition.setGetInputIndex(getInputValueDataDefinition);
1615 getInputValues.add(getInputValueDataDefinition);
1616 property.setGetInputValues(getInputValues);
1617 List<InputDefinition> inputs = new ArrayList<>();
1618 InputDefinition inputDefinition = new InputDefinition();
1619 inputDefinition.setName("inputName");
1620 inputDefinition.setUniqueId("abc12345");
1621 inputs.add(inputDefinition);
1622 Assertions.assertNotNull(inputs);
1624 testSubject.handleGetInputs(property, inputs);
1628 void testHandleGetInputs_null() {
1629 PropertyDataDefinition property = new PropertyDataDefinition();
1630 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1631 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1632 getInputValueDataDefinition.setInputName("inputName");
1633 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1634 getInputValues.add(getInputValueDataDefinition);
1635 property.setGetInputValues(getInputValues);
1636 List<InputDefinition> inputs = new ArrayList<>();
1637 Assertions.assertThrows(NoSuchElementException.class, () ->
1638 testSubject.handleGetInputs(property, inputs));
1642 void testFindInputByName() {
1643 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1644 getInput.setInputId("inputId");
1645 getInput.setInputName("inputName");
1646 List<InputDefinition> inputs = new ArrayList<>();
1647 InputDefinition inputDefinition = new InputDefinition();
1648 inputDefinition.setName("inputName");
1649 inputDefinition.setUniqueId("abc12345");
1650 inputs.add(inputDefinition);
1652 Assertions.assertNotNull(
1653 testSubject.findInputByName(inputs, getInput));
1657 void testAssociateComponentInstancePropertiesToComponent() {
1658 String yamlName = "yamlName";
1659 Resource resource = createParseResourceObject(true);
1660 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1661 Assertions.assertThrows(ComponentException.class, () ->
1662 testSubject.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties));
1666 void testAssociateComponentInstanceInputsToComponent() {
1667 String yamlName = "yamlName";
1668 Resource resource = createParseResourceObject(true);
1669 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1670 List<ComponentInstanceInput> componentInstanceInputList = new ArrayList<>();
1671 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1672 componentInstanceInput.setName("componentInstanceInputName");
1673 componentInstanceInputList.add(componentInstanceInput);
1674 Assertions.assertNotNull(resource);
1676 testSubject.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1680 void testAssociateDeploymentArtifactsToInstances() {
1681 String yamlName = "yamlName";
1682 Resource resource = createParseResourceObject(true);
1683 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1685 Assertions.assertThrows(ComponentException.class, () ->
1686 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1690 void testAssociateArtifactsToInstances() {
1691 String yamlName = "yamlName";
1692 Resource resource = createParseResourceObject(true);
1693 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1695 Assertions.assertThrows(ComponentException.class, () ->
1696 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1700 void testAssociateArtifactsToInstances2() {
1701 String yamlName = "yamlName";
1702 Resource resource = createParseResourceObject(true);
1703 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1705 Assertions.assertThrows(ComponentException.class, () ->
1706 testSubject.associateArtifactsToInstances(yamlName, resource, instDeploymentArtifacts));
1710 void testAssociateOrAddCalculatedCapReq() {
1711 String yamlName = "yamlName";
1712 Resource resource = createParseResourceObject(true);
1713 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1714 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1715 Assertions.assertThrows(ComponentException.class, () ->
1716 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1720 void testAssociateInstAttributeToComponentToInstances() {
1721 String yamlName = "yamlName";
1722 Resource resource = createParseResourceObject(true);
1723 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1724 Assertions.assertThrows(ComponentException.class, () ->
1725 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1729 void testThrowComponentExceptionByResource() {
1730 StorageOperationStatus status = StorageOperationStatus.OK;
1731 Resource resource = createParseResourceObject(true);
1732 Assertions.assertThrows(ComponentException.class, () ->
1733 testSubject.throwComponentExceptionByResource(status, resource));
1737 void testGetResourceAfterCreateRelations() {
1738 Resource resource = createParseResourceObject(true);
1739 Resource newResource = new Resource();
1741 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1742 .thenReturn(Either.left(newResource));
1743 Resource resourceAfterCreateRelations = testSubject.getResourceAfterCreateRelations(resource);
1744 assertNotNull(resourceAfterCreateRelations);
1748 void testSetCapabilityNamesTypes() {
1749 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1750 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1751 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1752 capabilityDefinition.setName("Capability");
1753 capabilityDefinition.setType("Resource");
1754 capabilityDefinitionList.add(capabilityDefinition);
1755 originCapabilities.put("Capability", capabilityDefinitionList);
1756 Map<String, List<UploadCapInfo>> uploadedCapabilities = new HashMap<>();
1757 List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
1758 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1759 uploadCapInfoList.add(uploadCapInfo);
1760 uploadedCapabilities.put("Capability", uploadCapInfoList);
1761 Assertions.assertNotNull(originCapabilities);
1763 testSubject.setCapabilityNamesTypes(originCapabilities, uploadedCapabilities);
1767 void testAssociateComponentInstanceInputsToComponent2() {
1768 String yamlName = "yamlName";
1769 Service service = createServiceObject(true);
1770 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1772 Assertions.assertNotNull(service);
1774 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1778 void testAssociateComponentInstanceInputsNotNullToComponent2() {
1779 String yamlName = "yamlName";
1780 Service service = createServiceObject(true);
1781 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1782 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
1783 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1784 componentInstanceInput.setName("ComponentInstanceInputName");
1785 componentInstanceInputs.add(componentInstanceInput);
1786 instInputs.put("instInputs", componentInstanceInputs);
1787 when(toscaOperationFacade.associateComponentInstanceInputsToComponent(any(Map.class),
1788 anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1789 Assertions.assertThrows(ComponentException.class, () ->
1790 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs));
1794 void testAssociateComponentInstancePropertiesToComponent2() {
1795 String yamlName = "yamlName";
1796 Service service = createServiceObject(true);
1797 Map<String, List<ComponentInstanceProperty>> instInputs = new HashMap<>();
1798 Map<String, List<ComponentInstanceProperty>> instInputMap = new HashMap<>();
1799 when(toscaOperationFacade.associateComponentInstancePropertiesToComponent(any(), anyString()))
1800 .thenReturn(Either.left(instInputMap));
1801 Assertions.assertNotNull(service);
1803 testSubject.associateComponentInstancePropertiesToComponent(yamlName, service, instInputs);
1807 void testAssociateDeploymentArtifactsToInstances2() {
1808 String yamlName = "yamlName";
1809 Service service = createServiceObject(true);
1810 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1812 Assertions.assertThrows(ComponentException.class, () ->
1813 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts));
1817 void testAssociateArtifactsToInstances3() {
1818 String yamlName = "yamlName";
1819 Service service = createServiceObject(true);
1820 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1822 Assertions.assertThrows(ComponentException.class, () ->
1823 testSubject.associateArtifactsToInstances(yamlName, service, instArtifacts));
1827 void testAssociateOrAddCalculatedCapReq2() {
1828 String yamlName = "yamlName";
1829 Service resource = createServiceObject(true);
1830 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1831 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1832 Assertions.assertThrows(ComponentException.class, () ->
1833 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1837 void testAssociateInstAttributeToComponentToInstances2() {
1838 String yamlName = "yamlName";
1839 Service resource = createServiceObject(true);
1840 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1841 Assertions.assertThrows(ComponentException.class, () ->
1842 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1846 void testAssociateRequirementsToService() {
1847 String yamlName = "yamlName";
1848 Service resource = createServiceObject(true);
1849 Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
1850 Assertions.assertThrows(ComponentException.class, () ->
1851 testSubject.associateRequirementsToService(yamlName, resource, requirements));
1855 void testAssociateCapabilitiesToService() {
1856 String yamlName = "yamlName";
1857 Service resource = createServiceObject(true);
1858 Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
1859 Assertions.assertThrows(ComponentException.class, () ->
1860 testSubject.associateCapabilitiesToService(yamlName, resource, capabilities));
1864 void testAssociateResourceInstances() {
1865 String yamlName = "yamlName";
1866 Service resource = createServiceObject(true);
1867 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1868 when(toscaOperationFacade.associateResourceInstances(any(Component.class),
1869 anyString(), any(ArrayList.class))).thenReturn(Either.left(relations));
1870 Assertions.assertNotNull(resource);
1872 testSubject.associateResourceInstances(yamlName, resource, relations);
1876 void testAddCapabilities() {
1877 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1878 String type = "type";
1879 List<CapabilityDefinition> capabilities = new ArrayList<>();
1880 Assertions.assertNotNull(type);
1882 testSubject.addCapabilities(originCapabilities, type, capabilities);
1886 void testAddCapabilitiesProperties() {
1887 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1888 List<UploadCapInfo> capabilities = new ArrayList<>();
1889 UploadCapInfo capability = new UploadCapInfo();
1890 List<UploadPropInfo> properties = new ArrayList<>();
1891 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1892 uploadPropInfo.setName("uploadPropInfoName");
1893 properties.add(uploadPropInfo);
1894 capability.setProperties(properties);
1895 capability.setName("capabilityName");
1896 capabilities.add(capability);
1897 Assertions.assertNotNull(capabilities);
1899 testSubject.addCapabilitiesProperties(newPropertiesMap, capabilities);
1903 void testGetServiceWithGroups() {
1904 String resourceId = "resourceId";
1905 Service service = createServiceObject(true);
1906 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1907 .thenReturn(Either.left(service));
1908 Assertions.assertNotNull(
1909 testSubject.getServiceWithGroups(resourceId));
1913 void testGetResourceWithGroups() {
1914 String resourceId = "resourceId";
1915 Resource resource = createParseResourceObject(false);
1916 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1917 .thenReturn(Either.left(resource));
1918 Assertions.assertNotNull(
1919 testSubject.getResourceWithGroups(resourceId));
1923 void testAssociateResourceInstances2() {
1924 String yamlName = "yamlName";
1925 Resource resource = createParseResourceObject(true);
1926 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1927 when(toscaOperationFacade.associateResourceInstances(any(Resource.class),
1928 anyString(), any(ArrayList.class))).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1929 Assertions.assertThrows(ComponentException.class, () ->
1930 testSubject.associateResourceInstances(yamlName, resource, relations));
1934 void testAddRelationsToRI() {
1935 String yamlName = "group.yml";
1936 Resource resource = createResourceObject(false);
1938 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1939 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1940 nodesInfoValue.getRequirements().get("requirements").get(0).setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1941 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1942 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1943 ComponentInstance componentInstance = new ComponentInstance();
1944 componentInstance.setName("zxjTestImportServiceAb");
1945 componentInstancesList.add(componentInstance);
1946 resource.setComponentInstances(componentInstancesList);
1947 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setLeftOccurrences("1");
1948 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setMaxOccurrences("1");
1949 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setCapability("tosca.capabilities.Node");
1950 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1951 RequirementDefinition requirementDefinition = new RequirementDefinition();
1952 requirementDefinition.setOwnerId("1");
1953 requirementDefinition.setUniqueId("2");
1954 requirementDefinition.setCapability("3");
1955 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1956 capabilityDefinition.setName("4");
1957 capabilityDefinition.setUniqueId("5");
1958 capabilityDefinition.setOwnerId("6");
1959 ResponseFormat responseFormat = new ResponseFormat();
1960 responseFormat.setStatus(200);
1961 Assertions.assertNotNull(resource);
1963 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1967 void testAddRelationsToRI_null() {
1968 String yamlName = "group.yml";
1969 Resource resource = createParseResourceObject(true);
1970 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1971 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1972 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1973 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1974 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1976 Assertions.assertThrows(ComponentException.class, () ->
1977 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList,
1982 void testAddRelationToRI() {
1983 String yamlName = "yamlName";
1984 Resource resource = createParseResourceObject(true);
1985 resource.setComponentInstances(creatComponentInstances());
1986 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1987 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1989 Assertions.assertNotNull(
1990 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1994 void testAddRelationToRI_null() {
1995 String yamlName = "yamlName.yml";
1996 Resource resource = createParseResourceObject(false);
1997 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1998 resource.setComponentInstances(componentInstancesList);
1999 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
2000 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2001 Assertions.assertNotNull(
2002 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
2006 void testFindVfcResource() {
2007 Service service = createServiceObject(true);
2008 String currVfcToscaName = "currVfcToscaName";
2009 String previousVfcToscaName = "previousVfcToscaName";
2010 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
2011 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2012 final CsarInfo csarInfo = getCsarInfo();
2013 Assertions.assertThrows(ComponentException.class, () ->
2014 testSubject.findVfcResource(csarInfo, service, currVfcToscaName, previousVfcToscaName,
2015 StorageOperationStatus.OK));
2018 private GroupDefinition getGroupDefinition() {
2019 GroupDefinition groupDefinition = new GroupDefinition();
2020 Map<String, String> members = new HashMap<>();
2021 members.put("members", "members");
2022 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2023 List<PropertyDataDefinition> properties = new ArrayList<>();
2024 groupDefinition.setInvariantName("groupDefinitionName");
2025 groupDefinition.setMembers(members);
2026 groupDefinition.setProperties(properties);
2027 groupDefinition.setCapabilities(capabilities);
2028 return groupDefinition;
2031 protected Resource createParseResourceObject(boolean afterCreate) {
2032 Resource resource = new Resource();
2033 resource.setName(RESOURCE_NAME);
2034 resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
2035 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
2036 resource.setDescription("My short description");
2037 List<String> tgs = new ArrayList<>();
2039 tgs.add(resource.getName());
2040 resource.setTags(tgs);
2041 List<String> template = new ArrayList<>();
2042 template.add("tosca.nodes.Root");
2043 resource.setDerivedFrom(template);
2044 resource.setVendorName("Motorola");
2045 resource.setVendorRelease("1.0.0");
2046 resource.setContactId("ya5467");
2047 resource.setIcon("defaulticon");
2048 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2049 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2050 requirements.put("test", requirementDefinitionList);
2051 resource.setRequirements(requirements);
2052 resource.setCost("cost");
2053 resource.setResourceVendorModelNumber("02312233");
2055 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2056 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2057 artifacts.put("artifact", artifactDefinition);
2058 resource.setArtifacts(artifacts);
2060 resource.setLicenseType("licType");
2063 resource.setName(resource.getName());
2064 resource.setVersion("0.1");
2065 resource.setUniqueId(resource.getName()
2066 .toLowerCase() + ":" + resource.getVersion());
2067 resource.setCreatorUserId(user.getUserId());
2068 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2069 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2074 protected CsarInfo getCsarInfo() {
2075 String csarUuid = "0010";
2076 User user = new User();
2077 Map<String, byte[]> csar = new HashMap<>();
2078 String vfReousrceName = "resouceName";
2079 String mainTemplateName = "mainTemplateName";
2080 String mainTemplateContent = null;
2082 mainTemplateContent = loadFileNameToJsonString("service_import_template.yml");
2083 } catch (IOException e) {
2084 e.printStackTrace();
2086 return new CsarInfo(user, csarUuid, csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
2089 private String loadFileNameToJsonString(String fileName) throws IOException {
2090 String sourceDir = "src/test/resources/normativeTypes";
2091 return loadFileNameToJsonString(sourceDir, fileName);
2094 private String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
2095 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
2096 byte[] fileContent = Files.readAllBytes(filePath);
2097 return new String(fileContent);
2100 protected Service createServiceObject(boolean afterCreate) {
2101 Service service = new Service();
2102 service.setUniqueId("sid");
2103 service.setName("Service");
2104 CategoryDefinition category = new CategoryDefinition();
2105 category.setName(SERVICE_CATEGORY);
2106 category.setIcons(Collections.singletonList("defaulticon"));
2107 List<CategoryDefinition> categories = new ArrayList<>();
2108 categories.add(category);
2109 service.setCategories(categories);
2110 service.setInstantiationType(INSTANTIATION_TYPE);
2112 service.setDescription("description");
2113 List<String> tgs = new ArrayList<>();
2114 tgs.add(service.getName());
2115 service.setTags(tgs);
2116 service.setIcon("defaulticon");
2117 service.setContactId("aa1234");
2118 service.setProjectCode("12345");
2119 service.setEcompGeneratedNaming(true);
2122 service.setVersion("0.1");
2123 service.setUniqueId(service.getName() + ":" + service.getVersion());
2124 service.setCreatorUserId(user.getUserId());
2125 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2130 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2131 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2132 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2133 assertParseResponse(actualResponse, expectedStatus, variables);
2136 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2137 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2138 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2139 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());