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.assertNotEquals;
21 import static org.junit.jupiter.api.Assertions.assertNotNull;
22 import static org.junit.jupiter.api.Assertions.assertTrue;
23 import static org.mockito.ArgumentMatchers.any;
24 import static org.mockito.ArgumentMatchers.anyBoolean;
25 import static org.mockito.ArgumentMatchers.anyMap;
26 import static org.mockito.ArgumentMatchers.anyString;
27 import static org.mockito.Mockito.mock;
28 import static org.mockito.Mockito.times;
29 import static org.mockito.Mockito.verify;
30 import static org.mockito.Mockito.when;
32 import fj.data.Either;
33 import java.io.IOException;
34 import java.nio.file.FileSystems;
35 import java.nio.file.Files;
36 import java.util.ArrayList;
37 import java.util.Collections;
38 import java.util.EnumMap;
39 import java.util.HashMap;
40 import java.util.List;
42 import java.util.Map.Entry;
43 import java.util.NoSuchElementException;
44 import org.apache.commons.collections.map.HashedMap;
45 import org.apache.commons.lang3.tuple.ImmutablePair;
46 import org.junit.jupiter.api.Assertions;
47 import org.junit.jupiter.api.BeforeEach;
48 import org.junit.jupiter.api.Test;
49 import org.mockito.MockitoAnnotations;
50 import org.openecomp.sdc.ElementOperationMock;
51 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
52 import org.openecomp.sdc.be.components.csar.CsarInfo;
53 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
54 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
55 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
56 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
57 import org.openecomp.sdc.be.dao.api.ActionStatus;
58 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
59 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
60 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
61 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
62 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
63 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
64 import org.openecomp.sdc.be.impl.ComponentsUtils;
65 import org.openecomp.sdc.be.model.ArtifactDefinition;
66 import org.openecomp.sdc.be.model.AttributeDefinition;
67 import org.openecomp.sdc.be.model.CapabilityDefinition;
68 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
69 import org.openecomp.sdc.be.model.Component;
70 import org.openecomp.sdc.be.model.ComponentInstance;
71 import org.openecomp.sdc.be.model.ComponentInstanceInput;
72 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
73 import org.openecomp.sdc.be.model.ComponentParametersView;
74 import org.openecomp.sdc.be.model.GroupDefinition;
75 import org.openecomp.sdc.be.model.InputDefinition;
76 import org.openecomp.sdc.be.model.InterfaceDefinition;
77 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
78 import org.openecomp.sdc.be.model.LifecycleStateEnum;
79 import org.openecomp.sdc.be.model.NodeTypeInfo;
80 import org.openecomp.sdc.be.model.PropertyDefinition;
81 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
82 import org.openecomp.sdc.be.model.RequirementDefinition;
83 import org.openecomp.sdc.be.model.Resource;
84 import org.openecomp.sdc.be.model.Service;
85 import org.openecomp.sdc.be.model.UploadCapInfo;
86 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
87 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
88 import org.openecomp.sdc.be.model.UploadPropInfo;
89 import org.openecomp.sdc.be.model.UploadReqInfo;
90 import org.openecomp.sdc.be.model.User;
91 import org.openecomp.sdc.be.model.category.CategoryDefinition;
92 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
93 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
94 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
95 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
96 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
97 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
98 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
99 import org.openecomp.sdc.be.user.Role;
100 import org.openecomp.sdc.common.api.Constants;
101 import org.openecomp.sdc.exception.ResponseFormat;
103 class ServiceImportParseLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
105 private static final String RESOURCE_NAME = "My-Resource_Name with space";
106 private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
107 private static final String GENERIC_ROOT_NAME = "tosca.nodes.Root";
108 private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF";
109 private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR";
110 private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF";
111 private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
112 private static final String RESOURCE_SUBCATEGORY = "Router";
114 private final ComponentsUtils componentsUtils = new ComponentsUtils(mock(AuditingManager.class));
115 private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
116 private final ServiceBusinessLogic serviceBusinessLogic = mock(ServiceBusinessLogic.class);
117 private final ICapabilityTypeOperation capabilityTypeOperation = mock(ICapabilityTypeOperation.class);
118 private final IElementOperation elementDao = mock(IElementOperation.class);
119 private final IInterfaceLifecycleOperation interfaceTypeOperation = mock(IInterfaceLifecycleOperation.class);
120 private final InputsBusinessLogic inputsBusinessLogic = mock(InputsBusinessLogic.class);
121 private final LifecycleBusinessLogic lifecycleBusinessLogic = mock(LifecycleBusinessLogic.class);
122 private final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic = mock(ComponentNodeFilterBusinessLogic.class);
124 private ResponseFormatManager responseManager = null;
125 private User user = null;
126 private ServiceImportParseLogic testSubject;
128 private ServiceImportParseLogic createTestSubject() {
129 return new ServiceImportParseLogic();
133 public void setup() {
134 MockitoAnnotations.openMocks(this);
137 mockElementDao = new ElementOperationMock();
139 // User data and management
141 user.setUserId("jh0003");
142 user.setFirstName("Jimmi");
143 user.setLastName("Hendrix");
144 user.setRole(Role.ADMIN.name());
145 responseManager = ResponseFormatManager.getInstance();
147 testSubject = createTestSubject();
148 testSubject.setComponentsUtils(componentsUtils);
149 testSubject.setToscaOperationFacade(toscaOperationFacade);
150 serviceBusinessLogic.setElementDao(elementDao);
151 testSubject.setServiceBusinessLogic(serviceBusinessLogic);
152 testSubject.setCapabilityTypeOperation(capabilityTypeOperation);
153 testSubject.setInterfaceTypeOperation(interfaceTypeOperation);
154 testSubject.setInputsBusinessLogic(inputsBusinessLogic);
155 testSubject.setLifecycleBusinessLogic(lifecycleBusinessLogic);
156 testSubject.setComponentNodeFilterBusinessLogic(componentNodeFilterBusinessLogic);
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 testAssociateCINodeFilterToComponent() {
1140 String yamlName = "yamlName.yml";
1141 Service service = createServiceObject(true);
1142 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1143 nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1145 when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1146 .thenReturn(StorageOperationStatus.OK);
1148 testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap);
1149 verify(componentNodeFilterBusinessLogic, times(1)).associateNodeFilterToComponentInstance(service.getUniqueId(),
1154 void testAssociateCINodeFilterToComponentFail() {
1155 String yamlName = "yamlName.yml";
1156 Service service = createServiceObject(true);
1157 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1158 nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1160 when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1161 .thenReturn(StorageOperationStatus.NOT_FOUND);
1163 Assertions.assertThrows(ComponentException.class, () -> testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap));
1167 void testCreateServiceTransaction() {
1168 Service service = createServiceObject(true);
1169 List<ComponentInstance> list = new ArrayList<>();
1170 ComponentInstance componentInstance = new ComponentInstance();
1171 componentInstance.setName("name");
1172 service.setComponentInstances(list);
1173 when(toscaOperationFacade.validateComponentNameExists(
1174 anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class))).thenReturn(Either.left(false));
1176 when(toscaOperationFacade.createToscaComponent(any(Service.class))).thenReturn(Either.left(service));
1178 Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true));
1182 void testCreateArtifactsPlaceHolderData() {
1183 Service service = createServiceObject(true);
1184 CategoryDefinition category = new CategoryDefinition();
1185 category.setName("");
1186 List<CategoryDefinition> categories = new ArrayList<>();
1187 categories.add(category);
1188 service.setCategories(categories);
1189 Assertions.assertNotNull(service);
1191 testSubject.createArtifactsPlaceHolderData(service, user);
1196 void testSetInformationalArtifactsPlaceHolder() {
1197 Service service = createServiceObject(true);
1199 Assertions.assertNotNull(service);
1201 testSubject.setInformationalArtifactsPlaceHolder(service, user);
1206 void testValidateNestedDerivedFromDuringUpdate() {
1207 Resource currentResource = createParseResourceObject(true);
1208 Resource updateInfoResource = createParseResourceObject(true);
1209 String key = "2323456";
1211 List<String> currentDerivedFromList = new ArrayList<>();
1212 currentDerivedFromList.add(key);
1213 currentResource.setDerivedFrom(currentDerivedFromList);
1214 List<String> updatedDerivedFromList = new ArrayList<>();
1215 updatedDerivedFromList.add("23344567778");
1216 updateInfoResource.setDerivedFrom(updatedDerivedFromList);
1218 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1219 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1221 Assertions.assertNotNull(
1222 testSubject.validateNestedDerivedFromDuringUpdate(currentResource, updateInfoResource, true));
1227 void testValidateDerivedFromExtending() {
1228 Resource currentResource = createParseResourceObject(true);
1229 Resource updateInfoResource = createParseResourceObject(true);
1231 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1232 .thenReturn(Either.left(false));
1234 Assertions.assertNotNull(
1235 testSubject.validateDerivedFromExtending(user, currentResource, updateInfoResource,
1236 AuditingActionEnum.IMPORT_RESOURCE));
1241 void testValidateResourceFieldsBeforeUpdate() {
1242 Resource currentResource = createParseResourceObject(true);
1243 Resource updateInfoResource = createParseResourceObject(true);
1245 Assertions.assertNotNull(currentResource);
1247 testSubject.validateResourceFieldsBeforeUpdate(currentResource, updateInfoResource, true, true);
1252 void testValidateResourceName() {
1253 Resource currentResource = createParseResourceObject(true);
1254 Resource updateInfoResource = createParseResourceObject(true);
1255 currentResource.setName("test1");
1256 updateInfoResource.setName("test2");
1258 Assertions.assertThrows(ComponentException.class, () ->
1259 testSubject.validateResourceName(currentResource, updateInfoResource, true, false));
1264 void testIsResourceNameEquals() {
1265 Resource currentResource = createParseResourceObject(true);
1266 Resource updateInfoResource = createParseResourceObject(true);
1268 boolean resourceNameEquals = testSubject.isResourceNameEquals(currentResource, updateInfoResource);
1269 assertTrue(resourceNameEquals);
1273 void testPrepareResourceForUpdate() {
1274 Resource oldResource = createParseResourceObject(true);
1275 Resource newResource = createParseResourceObject(true);
1276 when(lifecycleBusinessLogic.changeState(anyString(), any(User.class), any(LifeCycleTransitionEnum.class),
1277 any(LifecycleChangeInfoWithAction.class), anyBoolean(), anyBoolean())).thenReturn(Either.left(oldResource));
1279 Assertions.assertNotNull(
1280 testSubject.prepareResourceForUpdate(oldResource, newResource, user, true, true));
1285 void testFailOnChangeState() {
1286 ResponseFormat response = new ResponseFormat();
1287 Resource oldResource = createParseResourceObject(true);
1288 oldResource.setUniqueId("123");
1289 Resource newResource = createParseResourceObject(true);
1291 Assertions.assertThrows(ComponentException.class, () ->
1292 testSubject.failOnChangeState(response, user, oldResource, newResource));
1296 void testHandleResourceGenericType() {
1297 Resource resource = createParseResourceObject(true);
1299 Resource resource1 = testSubject.handleResourceGenericType(resource);
1300 assertNotEquals(resource, resource1);
1304 void testUpdateOrCreateGroups() {
1305 Resource resource = createParseResourceObject(true);
1306 Map<String, GroupDefinition> groups = new HashMap<>();
1307 Assertions.assertNotNull(resource);
1309 testSubject.updateOrCreateGroups(resource, groups);
1313 void testAddGroupsToCreateOrUpdate() {
1314 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1315 GroupDefinition groupDefinition = new GroupDefinition();
1316 groupDefinition.setInvariantName("groupDefinitionName");
1317 groupsFromResource.add(groupDefinition);
1318 List<GroupDefinition> groupsAsList = new ArrayList<>();
1319 GroupDefinition groupNewDefinition = getGroupDefinition();
1320 groupsAsList.add(groupNewDefinition);
1321 List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1322 List<GroupDefinition> groupsToCreate = new ArrayList<>();
1323 Assertions.assertNotNull(groupDefinition);
1325 testSubject.addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1329 void testAddGroupsToDelete() {
1330 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1331 GroupDefinition groupDefinition = new GroupDefinition();
1332 groupDefinition.setName("groupDefinitionName");
1333 groupsFromResource.add(groupDefinition);
1334 List<GroupDefinition> groupsAsList = new ArrayList<>();
1335 GroupDefinition groupNewDefinition = new GroupDefinition();
1336 groupNewDefinition.setName("groupNewDefinitionName");
1337 groupsAsList.add(groupNewDefinition);
1338 List<GroupDefinition> groupsToDelete = new ArrayList<>();
1339 Assertions.assertNotNull(groupsFromResource);
1341 testSubject.addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1345 void testUpdateGroupsMembersUsingResource() {
1346 Service component = createServiceObject(true);
1347 Map<String, GroupDefinition> groups = new HashMap<>();
1348 GroupDefinition groupDefinition = getGroupDefinition();
1349 groupDefinition.setMembers(null);
1350 groups.put("groupsMap", groupDefinition);
1352 Assertions.assertNotNull(
1353 testSubject.updateGroupsMembersUsingResource(groups, component));
1357 void testupdateGroupMembers() {
1358 Service component = createServiceObject(true);
1359 Map<String, GroupDefinition> groups = new HashMap<>();
1360 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1361 List<ComponentInstance> componentInstances = new ArrayList<>();
1362 String groupName = "groupName";
1363 Map<String, String> members = new HashMap<>();
1365 Assertions.assertThrows(ComponentException.class, () ->
1366 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1370 void testupdateGroupMembersNotNull() {
1371 Service component = createServiceObject(true);
1372 Map<String, GroupDefinition> groups = getGroups();
1373 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1374 List<ComponentInstance> componentInstances = new ArrayList<>();
1375 ComponentInstance componentInstance = new ComponentInstance();
1376 componentInstance.setName("componentInstanceName");
1377 componentInstance.setUniqueId("componentInstanceUniqueId");
1378 componentInstances.add(componentInstance);
1379 String groupName = "groupName";
1380 Map<String, String> members = new HashMap<>();
1381 members.put("members", "members");
1382 members.put("componentInstanceName", "members");
1384 Assertions.assertThrows(ComponentException.class, () ->
1385 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1389 void testFillResourceMetadataForServiceFailure() {
1390 String yamlName = "yamlName";
1391 Service resourceVf = createServiceObject(true);
1392 String nodeName = "nodeName";
1394 Assertions.assertThrows(ComponentException.class, () ->
1395 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1399 void testFillResourceMetadataForServiceWrongType() {
1400 String yamlName = "yamlName";
1401 Service resourceVf = createServiceObject(true);
1402 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "nodeName";
1404 Assertions.assertThrows(ComponentException.class, () ->
1405 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1409 void testFillResourceMetadataForServiceSuccess() {
1410 String yamlName = "yamlName";
1411 Service resourceVf = createServiceObject(true);
1412 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "VFC";
1414 Assertions.assertNotNull(
1415 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1419 void testpropagateStateToCertified() {
1420 String yamlName = "yamlName";
1421 Resource resource = createParseResourceObject(true);
1422 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1423 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1425 Assertions.assertNotNull(
1426 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1430 void testpropagateStateToCertifiedIsTrue() {
1431 String yamlName = "yamlName";
1432 Resource resource = createParseResourceObject(true);
1433 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1434 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1436 Assertions.assertNotNull(
1437 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1441 void testBuildValidComplexVfc2() {
1442 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1443 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1444 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1445 List<String> derivedFrom = new ArrayList<>();
1446 derivedFrom.add("derivedFrom");
1447 nodeTypeInfo.setDerivedFrom(derivedFrom);
1448 nodesInfo.put(nodeName, nodeTypeInfo);
1450 final CsarInfo csarInfo = getCsarInfo();
1451 Assertions.assertThrows(ComponentException.class, () ->
1452 testSubject.buildValidComplexVfc(csarInfo, nodeName, nodesInfo));
1456 void testUpdateGroupsOnResourceEmptyGroups() {
1457 Resource resource = createParseResourceObject(true);
1458 Map<String, GroupDefinition> groups = new HashMap<>();
1460 Assertions.assertNotNull(
1461 testSubject.updateGroupsOnResource(resource, groups));
1465 void testSetInformationalArtifactsPlaceHolder2() {
1466 Resource resource = createParseResourceObject(true);
1467 List<CategoryDefinition> categoryDefinitions = new ArrayList<>();
1468 CategoryDefinition categoryDefinition = new CategoryDefinition();
1469 categoryDefinition.setName("");
1470 categoryDefinitions.add(categoryDefinition);
1471 resource.setCategories(categoryDefinitions);
1472 Assertions.assertNotNull(resource);
1474 testSubject.setInformationalArtifactsPlaceHolder(resource, user);
1478 void testRollback() {
1479 Resource resource = createParseResourceObject(true);
1480 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1481 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1482 createdArtifacts.add(artifactDefinition);
1483 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1484 nodeTypesNewCreatedArtifacts.add(artifactDefinition);
1485 Assertions.assertNotNull(resource);
1487 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1491 void testRollback_NotNull() {
1492 Resource resource = createParseResourceObject(true);
1493 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1494 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1495 artifactDefinition.setArtifactName("artifactName");
1496 createdArtifacts.add(artifactDefinition);
1497 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1498 ArtifactDefinition artifactDefinition2 = new ArtifactDefinition();
1499 artifactDefinition2.setArtifactChecksum("artifactChecksum");
1500 nodeTypesNewCreatedArtifacts.add(artifactDefinition2);
1501 Assertions.assertNotNull(resource);
1503 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1507 void testCreateArtifactsPlaceHolderData2() {
1508 Resource resource = createParseResourceObject(true);
1510 Assertions.assertNotNull(resource);
1512 testSubject.createArtifactsPlaceHolderData(resource, user);
1516 void testHandleGroupsProperties() {
1517 Service service = createServiceObject(true);
1518 Map<String, GroupDefinition> groups = getGroups();
1519 Assertions.assertNotNull(service);
1521 testSubject.handleGroupsProperties(service, groups);
1525 void testHandleGroupsProperties2() {
1526 Resource resource = createParseResourceObject(true);
1527 Map<String, GroupDefinition> groups = getGroups();
1528 Assertions.assertNotNull(resource);
1530 testSubject.handleGroupsProperties(resource, groups);
1534 void testHandleGetInputs() {
1535 PropertyDataDefinition property = new PropertyDataDefinition();
1536 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1537 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1538 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1539 getInput.setInputId("inputId");
1540 getInput.setInputName("inputName");
1541 getInputValueDataDefinition.setInputName("inputName");
1542 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1543 getInputValueDataDefinition.setGetInputIndex(getInputValueDataDefinition);
1544 getInputValues.add(getInputValueDataDefinition);
1545 property.setGetInputValues(getInputValues);
1546 List<InputDefinition> inputs = new ArrayList<>();
1547 InputDefinition inputDefinition = new InputDefinition();
1548 inputDefinition.setName("inputName");
1549 inputDefinition.setUniqueId("abc12345");
1550 inputs.add(inputDefinition);
1551 Assertions.assertNotNull(inputs);
1553 testSubject.handleGetInputs(property, inputs);
1557 void testHandleGetInputs_null() {
1558 PropertyDataDefinition property = new PropertyDataDefinition();
1559 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1560 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1561 getInputValueDataDefinition.setInputName("inputName");
1562 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1563 getInputValues.add(getInputValueDataDefinition);
1564 property.setGetInputValues(getInputValues);
1565 List<InputDefinition> inputs = new ArrayList<>();
1566 Assertions.assertThrows(NoSuchElementException.class, () ->
1567 testSubject.handleGetInputs(property, inputs));
1571 void testFindInputByName() {
1572 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1573 getInput.setInputId("inputId");
1574 getInput.setInputName("inputName");
1575 List<InputDefinition> inputs = new ArrayList<>();
1576 InputDefinition inputDefinition = new InputDefinition();
1577 inputDefinition.setName("inputName");
1578 inputDefinition.setUniqueId("abc12345");
1579 inputs.add(inputDefinition);
1581 Assertions.assertNotNull(
1582 testSubject.findInputByName(inputs, getInput));
1586 void testAssociateComponentInstancePropertiesToComponent() {
1587 String yamlName = "yamlName";
1588 Resource resource = createParseResourceObject(true);
1589 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1590 Assertions.assertThrows(ComponentException.class, () ->
1591 testSubject.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties));
1595 void testAssociateComponentInstanceInputsToComponent() {
1596 String yamlName = "yamlName";
1597 Resource resource = createParseResourceObject(true);
1598 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1599 List<ComponentInstanceInput> componentInstanceInputList = new ArrayList<>();
1600 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1601 componentInstanceInput.setName("componentInstanceInputName");
1602 componentInstanceInputList.add(componentInstanceInput);
1603 Assertions.assertNotNull(resource);
1605 testSubject.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1609 void testAssociateDeploymentArtifactsToInstances() {
1610 String yamlName = "yamlName";
1611 Resource resource = createParseResourceObject(true);
1612 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1614 Assertions.assertThrows(ComponentException.class, () ->
1615 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1619 void testAssociateArtifactsToInstances() {
1620 String yamlName = "yamlName";
1621 Resource resource = createParseResourceObject(true);
1622 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1624 Assertions.assertThrows(ComponentException.class, () ->
1625 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1629 void testAssociateArtifactsToInstances2() {
1630 String yamlName = "yamlName";
1631 Resource resource = createParseResourceObject(true);
1632 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1634 Assertions.assertThrows(ComponentException.class, () ->
1635 testSubject.associateArtifactsToInstances(yamlName, resource, instDeploymentArtifacts));
1639 void testAssociateOrAddCalculatedCapReq() {
1640 String yamlName = "yamlName";
1641 Resource resource = createParseResourceObject(true);
1642 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1643 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1644 Assertions.assertThrows(ComponentException.class, () ->
1645 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1649 void testAssociateInstAttributeToComponentToInstances() {
1650 String yamlName = "yamlName";
1651 Resource resource = createParseResourceObject(true);
1652 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1653 Assertions.assertThrows(ComponentException.class, () ->
1654 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1658 void testThrowComponentExceptionByResource() {
1659 StorageOperationStatus status = StorageOperationStatus.OK;
1660 Resource resource = createParseResourceObject(true);
1661 Assertions.assertThrows(ComponentException.class, () ->
1662 testSubject.throwComponentExceptionByResource(status, resource));
1666 void testGetResourceAfterCreateRelations() {
1667 Resource resource = createParseResourceObject(true);
1668 Resource newResource = new Resource();
1670 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1671 .thenReturn(Either.left(newResource));
1672 Resource resourceAfterCreateRelations = testSubject.getResourceAfterCreateRelations(resource);
1673 assertNotNull(resourceAfterCreateRelations);
1677 void testSetCapabilityNamesTypes() {
1678 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1679 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1680 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1681 capabilityDefinition.setName("Capability");
1682 capabilityDefinition.setType("Resource");
1683 capabilityDefinitionList.add(capabilityDefinition);
1684 originCapabilities.put("Capability", capabilityDefinitionList);
1685 Map<String, List<UploadCapInfo>> uploadedCapabilities = new HashMap<>();
1686 List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
1687 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1688 uploadCapInfoList.add(uploadCapInfo);
1689 uploadedCapabilities.put("Capability", uploadCapInfoList);
1690 Assertions.assertNotNull(originCapabilities);
1692 testSubject.setCapabilityNamesTypes(originCapabilities, uploadedCapabilities);
1696 void testAssociateComponentInstanceInputsToComponent2() {
1697 String yamlName = "yamlName";
1698 Service service = createServiceObject(true);
1699 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1701 Assertions.assertNotNull(service);
1703 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1707 void testAssociateComponentInstanceInputsNotNullToComponent2() {
1708 String yamlName = "yamlName";
1709 Service service = createServiceObject(true);
1710 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1711 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
1712 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1713 componentInstanceInput.setName("ComponentInstanceInputName");
1714 componentInstanceInputs.add(componentInstanceInput);
1715 instInputs.put("instInputs", componentInstanceInputs);
1716 when(toscaOperationFacade.associateComponentInstanceInputsToComponent(any(Map.class),
1717 anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1718 Assertions.assertThrows(ComponentException.class, () ->
1719 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs));
1723 void testAssociateComponentInstancePropertiesToComponent2() {
1724 String yamlName = "yamlName";
1725 Service service = createServiceObject(true);
1726 Map<String, List<ComponentInstanceProperty>> instInputs = new HashMap<>();
1727 Map<String, List<ComponentInstanceProperty>> instInputMap = new HashMap<>();
1728 when(toscaOperationFacade.associateComponentInstancePropertiesToComponent(any(), anyString()))
1729 .thenReturn(Either.left(instInputMap));
1730 Assertions.assertNotNull(service);
1732 testSubject.associateComponentInstancePropertiesToComponent(yamlName, service, instInputs);
1736 void testAssociateDeploymentArtifactsToInstances2() {
1737 String yamlName = "yamlName";
1738 Service service = createServiceObject(true);
1739 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1741 Assertions.assertThrows(ComponentException.class, () ->
1742 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts));
1746 void testAssociateArtifactsToInstances3() {
1747 String yamlName = "yamlName";
1748 Service service = createServiceObject(true);
1749 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1751 Assertions.assertThrows(ComponentException.class, () ->
1752 testSubject.associateArtifactsToInstances(yamlName, service, instArtifacts));
1756 void testAssociateOrAddCalculatedCapReq2() {
1757 String yamlName = "yamlName";
1758 Service resource = createServiceObject(true);
1759 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1760 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1761 Assertions.assertThrows(ComponentException.class, () ->
1762 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1766 void testAssociateInstAttributeToComponentToInstances2() {
1767 String yamlName = "yamlName";
1768 Service resource = createServiceObject(true);
1769 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1770 Assertions.assertThrows(ComponentException.class, () ->
1771 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1775 void testAssociateRequirementsToService() {
1776 String yamlName = "yamlName";
1777 Service resource = createServiceObject(true);
1778 Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
1779 Assertions.assertThrows(ComponentException.class, () ->
1780 testSubject.associateRequirementsToService(yamlName, resource, requirements));
1784 void testAssociateCapabilitiesToService() {
1785 String yamlName = "yamlName";
1786 Service resource = createServiceObject(true);
1787 Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
1788 Assertions.assertThrows(ComponentException.class, () ->
1789 testSubject.associateCapabilitiesToService(yamlName, resource, capabilities));
1793 void testAssociateResourceInstances() {
1794 String yamlName = "yamlName";
1795 Service resource = createServiceObject(true);
1796 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1797 when(toscaOperationFacade.associateResourceInstances(any(Component.class),
1798 anyString(), any(ArrayList.class))).thenReturn(Either.left(relations));
1799 Assertions.assertNotNull(resource);
1801 testSubject.associateResourceInstances(yamlName, resource, relations);
1805 void testAddCapabilities() {
1806 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1807 String type = "type";
1808 List<CapabilityDefinition> capabilities = new ArrayList<>();
1809 Assertions.assertNotNull(type);
1811 testSubject.addCapabilities(originCapabilities, type, capabilities);
1815 void testAddCapabilitiesProperties() {
1816 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1817 List<UploadCapInfo> capabilities = new ArrayList<>();
1818 UploadCapInfo capability = new UploadCapInfo();
1819 List<UploadPropInfo> properties = new ArrayList<>();
1820 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1821 uploadPropInfo.setName("uploadPropInfoName");
1822 properties.add(uploadPropInfo);
1823 capability.setProperties(properties);
1824 capability.setName("capabilityName");
1825 capabilities.add(capability);
1826 Assertions.assertNotNull(capabilities);
1828 testSubject.addCapabilitiesProperties(newPropertiesMap, capabilities);
1832 void testGetServiceWithGroups() {
1833 String resourceId = "resourceId";
1834 Service service = createServiceObject(true);
1835 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1836 .thenReturn(Either.left(service));
1837 Assertions.assertNotNull(
1838 testSubject.getServiceWithGroups(resourceId));
1842 void testGetResourceWithGroups() {
1843 String resourceId = "resourceId";
1844 Resource resource = createParseResourceObject(false);
1845 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1846 .thenReturn(Either.left(resource));
1847 Assertions.assertNotNull(
1848 testSubject.getResourceWithGroups(resourceId));
1852 void testAssociateResourceInstances2() {
1853 String yamlName = "yamlName";
1854 Resource resource = createParseResourceObject(true);
1855 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1856 when(toscaOperationFacade.associateResourceInstances(any(Resource.class),
1857 anyString(), any(ArrayList.class))).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1858 Assertions.assertThrows(ComponentException.class, () ->
1859 testSubject.associateResourceInstances(yamlName, resource, relations));
1863 void testAddRelationsToRI() {
1864 String yamlName = "group.yml";
1865 Resource resource = createResourceObject(false);
1867 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1868 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1869 nodesInfoValue.getRequirements().get("requirements").get(0).setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1870 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1871 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1872 ComponentInstance componentInstance = new ComponentInstance();
1873 componentInstance.setName("zxjTestImportServiceAb");
1874 componentInstancesList.add(componentInstance);
1875 resource.setComponentInstances(componentInstancesList);
1876 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setLeftOccurrences("1");
1877 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setMaxOccurrences("1");
1878 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setCapability("tosca.capabilities.Node");
1879 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1880 RequirementDefinition requirementDefinition = new RequirementDefinition();
1881 requirementDefinition.setOwnerId("1");
1882 requirementDefinition.setUniqueId("2");
1883 requirementDefinition.setCapability("3");
1884 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1885 capabilityDefinition.setName("4");
1886 capabilityDefinition.setUniqueId("5");
1887 capabilityDefinition.setOwnerId("6");
1888 ResponseFormat responseFormat = new ResponseFormat();
1889 responseFormat.setStatus(200);
1890 Assertions.assertNotNull(resource);
1892 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1896 void testAddRelationsToRI_null() {
1897 String yamlName = "group.yml";
1898 Resource resource = createParseResourceObject(true);
1899 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1900 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1901 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1902 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1903 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1905 Assertions.assertThrows(ComponentException.class, () ->
1906 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList,
1911 void testAddRelationToRI() {
1912 String yamlName = "yamlName";
1913 Resource resource = createParseResourceObject(true);
1914 resource.setComponentInstances(creatComponentInstances());
1915 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1916 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1918 Assertions.assertNotNull(
1919 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1923 void testAddRelationToRI_null() {
1924 String yamlName = "yamlName.yml";
1925 Resource resource = createParseResourceObject(false);
1926 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1927 resource.setComponentInstances(componentInstancesList);
1928 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1929 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1930 Assertions.assertNotNull(
1931 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1935 void testFindVfcResource() {
1936 Service service = createServiceObject(true);
1937 String currVfcToscaName = "currVfcToscaName";
1938 String previousVfcToscaName = "previousVfcToscaName";
1939 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
1940 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1941 final CsarInfo csarInfo = getCsarInfo();
1942 Assertions.assertThrows(ComponentException.class, () ->
1943 testSubject.findVfcResource(csarInfo, service, currVfcToscaName, previousVfcToscaName,
1944 StorageOperationStatus.OK));
1947 private GroupDefinition getGroupDefinition() {
1948 GroupDefinition groupDefinition = new GroupDefinition();
1949 Map<String, String> members = new HashMap<>();
1950 members.put("members", "members");
1951 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1952 List<PropertyDataDefinition> properties = new ArrayList<>();
1953 groupDefinition.setInvariantName("groupDefinitionName");
1954 groupDefinition.setMembers(members);
1955 groupDefinition.setProperties(properties);
1956 groupDefinition.setCapabilities(capabilities);
1957 return groupDefinition;
1960 protected Resource createParseResourceObject(boolean afterCreate) {
1961 Resource resource = new Resource();
1962 resource.setName(RESOURCE_NAME);
1963 resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
1964 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
1965 resource.setDescription("My short description");
1966 List<String> tgs = new ArrayList<>();
1968 tgs.add(resource.getName());
1969 resource.setTags(tgs);
1970 List<String> template = new ArrayList<>();
1971 template.add("tosca.nodes.Root");
1972 resource.setDerivedFrom(template);
1973 resource.setVendorName("Motorola");
1974 resource.setVendorRelease("1.0.0");
1975 resource.setContactId("ya5467");
1976 resource.setIcon("defaulticon");
1977 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1978 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1979 requirements.put("test", requirementDefinitionList);
1980 resource.setRequirements(requirements);
1981 resource.setCost("cost");
1982 resource.setResourceVendorModelNumber("02312233");
1984 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1985 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1986 artifacts.put("artifact", artifactDefinition);
1987 resource.setArtifacts(artifacts);
1989 resource.setLicenseType("licType");
1992 resource.setName(resource.getName());
1993 resource.setVersion("0.1");
1994 resource.setUniqueId(resource.getName()
1995 .toLowerCase() + ":" + resource.getVersion());
1996 resource.setCreatorUserId(user.getUserId());
1997 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
1998 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2003 protected CsarInfo getCsarInfo() {
2004 String csarUuid = "0010";
2005 User user = new User();
2006 Map<String, byte[]> csar = new HashMap<>();
2007 String vfReousrceName = "resouceName";
2008 String mainTemplateName = "mainTemplateName";
2009 String mainTemplateContent = null;
2011 mainTemplateContent = loadFileNameToJsonString("service_import_template.yml");
2012 } catch (IOException e) {
2013 e.printStackTrace();
2015 return new CsarInfo(user, csarUuid, csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
2018 private String loadFileNameToJsonString(String fileName) throws IOException {
2019 String sourceDir = "src/test/resources/normativeTypes";
2020 return loadFileNameToJsonString(sourceDir, fileName);
2023 private String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
2024 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
2025 byte[] fileContent = Files.readAllBytes(filePath);
2026 return new String(fileContent);
2029 protected Service createServiceObject(boolean afterCreate) {
2030 Service service = new Service();
2031 service.setUniqueId("sid");
2032 service.setName("Service");
2033 CategoryDefinition category = new CategoryDefinition();
2034 category.setName(SERVICE_CATEGORY);
2035 category.setIcons(Collections.singletonList("defaulticon"));
2036 List<CategoryDefinition> categories = new ArrayList<>();
2037 categories.add(category);
2038 service.setCategories(categories);
2039 service.setInstantiationType(INSTANTIATION_TYPE);
2041 service.setDescription("description");
2042 List<String> tgs = new ArrayList<>();
2043 tgs.add(service.getName());
2044 service.setTags(tgs);
2045 service.setIcon("defaulticon");
2046 service.setContactId("aa1234");
2047 service.setProjectCode("12345");
2048 service.setEcompGeneratedNaming(true);
2051 service.setVersion("0.1");
2052 service.setUniqueId(service.getName() + ":" + service.getVersion());
2053 service.setCreatorUserId(user.getUserId());
2054 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2059 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2060 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2061 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2062 assertParseResponse(actualResponse, expectedStatus, variables);
2065 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2066 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2067 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2068 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());