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.when;
29 import fj.data.Either;
30 import java.io.IOException;
31 import java.nio.file.FileSystems;
32 import java.nio.file.Files;
33 import java.util.ArrayList;
34 import java.util.Collections;
35 import java.util.EnumMap;
36 import java.util.HashMap;
37 import java.util.HashSet;
38 import java.util.List;
40 import java.util.Map.Entry;
41 import java.util.NoSuchElementException;
43 import org.apache.commons.collections.map.HashedMap;
44 import org.apache.commons.lang3.tuple.ImmutablePair;
45 import org.junit.jupiter.api.Assertions;
46 import org.junit.jupiter.api.BeforeEach;
47 import org.junit.jupiter.api.Test;
48 import org.mockito.Mockito;
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.UploadPropInfo;
88 import org.openecomp.sdc.be.model.UploadReqInfo;
89 import org.openecomp.sdc.be.model.User;
90 import org.openecomp.sdc.be.model.category.CategoryDefinition;
91 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
92 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
93 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
94 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
95 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
96 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
97 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
98 import org.openecomp.sdc.be.user.Role;
99 import org.openecomp.sdc.common.api.Constants;
100 import org.openecomp.sdc.exception.ResponseFormat;
102 class ServiceImportParseLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
104 private static final String RESOURCE_NAME = "My-Resource_Name with space";
105 private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
106 private static final String GENERIC_ROOT_NAME = "tosca.nodes.Root";
107 private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF";
108 private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR";
109 private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF";
110 private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
111 private static final String RESOURCE_SUBCATEGORY = "Router";
113 private final ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
114 private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
115 private final ServiceBusinessLogic serviceBusinessLogic = Mockito.mock(ServiceBusinessLogic.class);
116 private final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class);
117 private final IElementOperation elementDao = Mockito.mock(IElementOperation.class);
118 private final IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class);
119 private final InputsBusinessLogic inputsBusinessLogic = Mockito.mock(InputsBusinessLogic.class);
120 private final LifecycleBusinessLogic lifecycleBusinessLogic = Mockito.mock(LifecycleBusinessLogic.class);
122 private ResponseFormatManager responseManager = null;
123 private User user = null;
124 private ServiceImportParseLogic testSubject;
126 private ServiceImportParseLogic createTestSubject() {
127 return new ServiceImportParseLogic();
131 public void setup() {
132 MockitoAnnotations.initMocks(this);
135 mockElementDao = new ElementOperationMock();
137 // User data and management
139 user.setUserId("jh0003");
140 user.setFirstName("Jimmi");
141 user.setLastName("Hendrix");
142 user.setRole(Role.ADMIN.name());
143 responseManager = ResponseFormatManager.getInstance();
145 testSubject = createTestSubject();
146 testSubject.setComponentsUtils(componentsUtils);
147 testSubject.setToscaOperationFacade(toscaOperationFacade);
148 serviceBusinessLogic.setElementDao(elementDao);
149 testSubject.setServiceBusinessLogic(serviceBusinessLogic);
150 testSubject.setCapabilityTypeOperation(capabilityTypeOperation);
151 testSubject.setInterfaceTypeOperation(interfaceTypeOperation);
152 testSubject.setInputsBusinessLogic(inputsBusinessLogic);
153 testSubject.setLifecycleBusinessLogic(lifecycleBusinessLogic);
157 void testFindNodeTypesArtifactsToHandle() {
158 testSubject = createTestSubject();
159 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
160 final Service service = createServiceObject(false);
161 Assertions.assertNotNull(
162 this.testSubject.findNodeTypesArtifactsToHandle(
163 nodeTypesInfo, getCsarInfo(), service));
168 void testBuildNodeTypeYaml() {
169 Map.Entry<String, Object> nodeNameValue = new Entry<String, Object>() {
171 public String getKey() {
176 public Object getValue() {
181 public Object setValue(Object value) {
185 Map<String, Object> mapToConvert = new HashMap<>();
186 String nodeResourceType = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
188 final CsarInfo csarInfo = getCsarInfo();
189 Assertions.assertThrows(ComponentException.class, () ->
190 testSubject.buildNodeTypeYaml(nodeNameValue, mapToConvert, nodeResourceType, csarInfo));
195 void testFindAddNodeTypeArtifactsToHandle() {
197 Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
198 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
199 String namespace = "namespace";
201 ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
202 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
203 final Service service = createServiceObject(false);
204 Resource resource = new Resource();
205 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
206 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
207 .thenReturn(getCompLatestResult);
209 final CsarInfo csarInfo = getCsarInfo();
210 Assertions.assertThrows(ComponentException.class, () ->
211 testSubject.findAddNodeTypeArtifactsToHandle(csarInfo, nodeTypesArtifactsToHandle, service,
212 extractedVfcsArtifacts, namespace, p1));
217 void testFindAddNodeTypeArtifactsToHandleNotNull() {
219 Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
220 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
221 String namespace = "namespace";
222 List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
223 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
224 artifactDefinition.setArtifactName("artifactDefinitionName");
225 vfcArtifacts.add(artifactDefinition);
226 extractedVfcsArtifacts.put(namespace, vfcArtifacts);
227 ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
228 Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
229 final Service service = createServiceObject(false);
230 Resource resource = new Resource();
231 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
232 when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
233 .thenReturn(getCompLatestResult);
234 Assertions.assertNotNull(extractedVfcsArtifacts);
235 testSubject.findAddNodeTypeArtifactsToHandle(getCsarInfo(), nodeTypesArtifactsToHandle, service,
236 extractedVfcsArtifacts, namespace, p1);
240 void testHandleAndAddExtractedVfcsArtifacts() {
241 List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
242 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
243 artifactDefinition.setArtifactName("artifactDefinitionName");
244 vfcArtifacts.add(artifactDefinition);
245 List<ArtifactDefinition> artifactsToAdd = new ArrayList<>();
246 ArtifactDefinition artifactDefinitionToAdd = new ArtifactDefinition();
247 artifactDefinitionToAdd.setArtifactName("artifactDefinitionToAddName");
248 artifactsToAdd.add(artifactDefinitionToAdd);
249 Assertions.assertNotNull(vfcArtifacts);
251 testSubject.handleAndAddExtractedVfcsArtifacts(vfcArtifacts, artifactsToAdd);
255 void testFindNodeTypeArtifactsToHandle() {
257 Resource curNodeType = createParseResourceObject(true);
258 List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
260 Assertions.assertNull(
261 testSubject.findNodeTypeArtifactsToHandle(curNodeType, extractedArtifacts));
265 void testCollectExistingArtifacts() {
267 Resource curNodeType = createParseResourceObject(true);
268 Assertions.assertNotNull(
269 testSubject.collectExistingArtifacts(curNodeType));
273 void testPutFoundArtifacts() {
274 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
275 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
276 artifactsToUpload.add(artifactDefinition);
277 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
278 artifactsToUpdate.add(artifactDefinition);
279 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
280 artifactsToDelete.add(artifactDefinition);
281 Assertions.assertNotNull(
282 testSubject.putFoundArtifacts(artifactsToUpload, artifactsToUpdate, artifactsToDelete));
286 void testProcessExistingNodeTypeArtifacts() {
287 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
288 List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
289 extractedArtifacts.add(artifactDefinition);
290 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
291 artifactsToUpload.add(artifactDefinition);
292 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
293 artifactsToUpdate.add(artifactDefinition);
294 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
295 artifactsToDelete.add(artifactDefinition);
296 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
297 existingArtifacts.put("test", artifactDefinition);
298 Assertions.assertThrows(ComponentException.class, () ->
299 testSubject.processExistingNodeTypeArtifacts(extractedArtifacts, artifactsToUpload, artifactsToUpdate,
300 artifactsToDelete, existingArtifacts));
305 void testProcessNodeTypeArtifact() {
306 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
307 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
308 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
309 ArtifactDefinition existingArtifact = new ArtifactDefinition();
310 existingArtifact.setArtifactName("ArtifactName");
311 existingArtifact.setArtifactType("ArtifactType");
312 existingArtifact.setArtifactChecksum("ArtifactChecksum");
313 existingArtifacts.put("existingArtifactMap", existingArtifact);
314 ArtifactDefinition currNewArtifact = new ArtifactDefinition();
315 currNewArtifact.setArtifactName("ArtifactName");
316 currNewArtifact.setArtifactType("ArtifactType");
317 currNewArtifact.setPayload("Payload".getBytes());
318 Assertions.assertNotNull(existingArtifact);
319 testSubject.processNodeTypeArtifact(artifactsToUpload, artifactsToUpdate, existingArtifacts, currNewArtifact);
323 void testUpdateFoundArtifact() {
324 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
325 ArtifactDefinition currNewArtifact = new ArtifactDefinition();
326 currNewArtifact.setArtifactChecksum("090909");
327 currNewArtifact.setPayloadData("data");
328 ArtifactDefinition foundArtifact = new ArtifactDefinition();
329 foundArtifact.setArtifactChecksum("08767");
330 Assertions.assertNotNull(currNewArtifact);
332 testSubject.updateFoundArtifact(artifactsToUpdate, currNewArtifact, foundArtifact);
336 void testIsArtifactDeletionRequired() {
337 String artifactId = "artifactId";
338 byte[] artifactFileBytes = new byte[100];
339 boolean isFromCsar = true;
340 Assertions.assertFalse(testSubject.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar));
344 void testFillGroupsFinalFields() {
345 List<GroupDefinition> groupsAsList = new ArrayList<>();
346 GroupDefinition groupDefinition = new GroupDefinition();
347 groupDefinition.setName("groupDefinitionName");
348 groupsAsList.add(groupDefinition);
349 Assertions.assertNotNull(groupsAsList);
350 testSubject.fillGroupsFinalFields(groupsAsList);
354 void testGetComponentTypeForResponse() {
355 Resource resource = createParseResourceObject(true);
356 Assertions.assertNotNull(
357 testSubject.getComponentTypeForResponse(resource));
361 void testGetComponentTypeForResponseByService() {
362 Service service = createServiceObject(true);
363 Assertions.assertNotNull(
364 testSubject.getComponentTypeForResponse(service));
368 void testIsfillGroupMemebersRecursivlyStopCondition() {
369 String groupName = "groupName";
370 Map<String, GroupDefinition> allGroups = new HashMap<>();
371 Set<String> allGroupMembers = new HashSet<>();
372 Assertions.assertTrue(testSubject.isfillGroupMemebersRecursivlyStopCondition(groupName, allGroups, allGroupMembers));
376 void testIsfillGroupMemebersRecursivlyStopCondition2() {
377 String groupName = "groupName";
378 Map<String, GroupDefinition> allGroups = new HashMap<>();
379 GroupDefinition groupDefinition = new GroupDefinition();
380 Map<String, String> members = new HashMap<>();
381 members.put("members", "members");
382 groupDefinition.setMembers(members);
383 allGroups.put(groupName, groupDefinition);
384 Set<String> allGroupMembers = new HashSet<>();
385 Assertions.assertTrue(testSubject.isfillGroupMemebersRecursivlyStopCondition(groupName, allGroups, allGroupMembers));
389 void testBuildValidComplexVfc() {
390 Resource resource = createParseResourceObject(true);
391 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
392 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
393 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
394 List<String> derivedFrom = new ArrayList<>();
395 derivedFrom.add("derivedFrom");
396 nodeTypeInfo.setDerivedFrom(derivedFrom);
397 nodesInfo.put(nodeName, nodeTypeInfo);
398 final CsarInfo csarInfo = getCsarInfo();
399 Assertions.assertThrows(ComponentException.class, () ->
400 testSubject.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo));
405 void testValidateResourceBeforeCreate() {
406 Resource resource = createParseResourceObject(true);
408 testSubject.getServiceBusinessLogic().setElementDao(elementDao);
409 final CsarInfo csarInfo = getCsarInfo();
410 Assertions.assertThrows(ComponentException.class, () ->
411 testSubject.validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, false, csarInfo));
416 void testValidateResourceType() {
417 Resource resource = createParseResourceObject(true);
418 Assertions.assertNotNull(
419 testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
423 void testValidateResourceTypeIsEmpty() {
424 Resource resource = new Resource();
425 resource.setResourceType(null);
426 Assertions.assertNotNull(
427 testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
431 void testValidateLifecycleTypesCreate() {
432 Resource resource = createParseResourceObject(true);
433 Map<String, InterfaceDefinition> mapInterfaces = new HashMap<>();
434 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
435 String uniqueId = "01932342212";
436 interfaceDefinition.setUniqueId(uniqueId);
437 mapInterfaces.put("uniqueId", interfaceDefinition);
438 resource.setInterfaces(mapInterfaces);
439 when(interfaceTypeOperation.getInterface(anyString()))
440 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
441 Assertions.assertNotNull(
442 testSubject.validateLifecycleTypesCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
446 void testValidateCapabilityTypesCreate() {
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 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
456 thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
457 Assertions.assertNotNull(
458 testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
459 AuditingActionEnum.IMPORT_RESOURCE, true));
464 void testValidateCapabilityTypesCreateWhenHaveCapability() {
465 Resource resource = createParseResourceObject(true);
466 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
467 String uniqueId = "18982938994";
468 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
469 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
470 capabilityDefinitionList.add(capabilityDefinition);
471 capabilities.put(uniqueId, capabilityDefinitionList);
472 resource.setCapabilities(capabilities);
473 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
474 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
475 thenReturn(Either.left(capabilityTypeDefinition));
477 Assertions.assertNotNull(
478 testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
479 AuditingActionEnum.IMPORT_RESOURCE, true));
484 void testValidateCapabilityTypeExists() {
485 Resource resource = createParseResourceObject(true);
486 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
487 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
489 Assertions.assertNotNull(
490 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
491 AuditingActionEnum.IMPORT_RESOURCE,
492 eitherResult, typeEntry, false));
497 void testValidateCapabilityTypeExistsWhenPropertiesIsNull() {
498 Resource resource = createParseResourceObject(true);
499 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
500 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
502 String uniqueId = "0987348532";
503 PropertyDefinition propertyDefinition = new PropertyDefinition();
504 Map<String, PropertyDefinition> properties = new HashMap<>();
505 properties.put(uniqueId, propertyDefinition);
506 capabilityTypeDefinition.setProperties(properties);
508 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
509 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
510 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
511 capabilityDefinitionList.add(capabilityDefinition);
512 capabilities.put(uniqueId, capabilityDefinitionList);
513 resource.setCapabilities(capabilities);
515 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
516 thenReturn(Either.left(capabilityTypeDefinition));
517 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
519 Assertions.assertNotNull(
520 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
521 AuditingActionEnum.IMPORT_RESOURCE,
522 eitherResult, typeEntry, false));
527 void testValidateCapabilityTypeExistsWhenPropertiesNotNull() {
528 Resource resource = createParseResourceObject(true);
529 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
530 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
532 String uniqueId = "0987348532";
533 PropertyDefinition propertyDefinition = new PropertyDefinition();
534 propertyDefinition.setName(uniqueId);
535 Map<String, PropertyDefinition> properties = new HashMap<>();
536 properties.put(uniqueId, propertyDefinition);
537 capabilityTypeDefinition.setProperties(properties);
539 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
541 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
542 List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
543 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
544 componentInstanceProperty.setValueUniqueUid(uniqueId);
545 componentInstanceProperty.setName(uniqueId);
546 componentInstancePropertyList.add(componentInstanceProperty);
547 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
548 capabilityDefinition.setProperties(componentInstancePropertyList);
549 capabilityDefinitionList.add(capabilityDefinition);
551 capabilities.put(uniqueId, capabilityDefinitionList);
552 resource.setCapabilities(capabilities);
554 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
555 thenReturn(Either.left(capabilityTypeDefinition));
556 for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
558 Assertions.assertNotNull(
559 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
560 AuditingActionEnum.IMPORT_RESOURCE,
561 eitherResult, typeEntry, false));
566 void testValidateCapabilityTypeExists2() {
567 Resource resource = createParseResourceObject(true);
568 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
569 when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
570 thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
572 for (String type : resource.getRequirements().keySet()) {
573 Assertions.assertNotNull(
574 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
575 resource.getRequirements().get(type), AuditingActionEnum.IMPORT_RESOURCE, eitherResult, type,
582 void testValidateResourceFieldsBeforeCreate() {
583 Resource resource = createParseResourceObject(true);
584 Assertions.assertThrows(ComponentException.class, () ->
585 testSubject.validateResourceFieldsBeforeCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
589 void testValidateDerivedFromExist() {
590 Resource resource = createParseResourceObject(true);
591 when(toscaOperationFacade.validateToscaResourceNameExists(anyString())).thenReturn(Either.left(true));
592 Assertions.assertNotNull(resource);
594 testSubject.validateDerivedFromExist(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
598 void testValidateLicenseType() {
599 Resource resource = createParseResourceObject(true);
601 Assertions.assertThrows(ComponentException.class, () ->
602 testSubject.validateLicenseType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
608 void testValidateCost() {
609 Resource resource = createParseResourceObject(true);
610 Assertions.assertThrows(ComponentException.class, () ->
611 testSubject.validateCost(resource));
615 void testValidateResourceVendorModelNumber() {
616 Resource resource = createParseResourceObject(true);
617 Assertions.assertNotNull(resource);
619 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
623 void testValidateResourceVendorModelNumberWrongLen() {
624 Resource resource = createParseResourceObject(true);
625 resource.setResourceVendorModelNumber("000000000011122221111222333444443222556677788778889999998776554332340");
626 Assertions.assertThrows(ComponentException.class, () ->
627 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
631 void testValidateResourceVendorModelNumberWrongValue() {
632 Resource resource = createParseResourceObject(true);
633 resource.setResourceVendorModelNumber("");
634 Assertions.assertNotNull(resource);
636 testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
640 void testValidateVendorReleaseName() {
641 Resource resource = createParseResourceObject(true);
642 resource.setVendorRelease("0.1");
643 Assertions.assertNotNull(resource);
645 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
649 void testValidateVendorReleaseNameFailure() {
650 Resource resource = createParseResourceObject(true);
651 resource.setVendorRelease("");
652 Assertions.assertThrows(ComponentException.class, () ->
653 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
658 void testValidateVendorReleaseNameWrongLen() {
659 Resource resource = createParseResourceObject(true);
660 resource.setVendorRelease("000000000011122221111222333444443222556677788778889999998776554332340");
661 Assertions.assertThrows(ComponentException.class, () ->
662 testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
667 void testValidateCategory() {
668 Resource resource = createParseResourceObject(true);
669 Assertions.assertThrows(ComponentException.class, () ->
670 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
674 void testValidateEmptyCategory() {
675 Resource resource = createParseResourceObject(true);
676 resource.setCategories(null);
677 Assertions.assertThrows(ComponentException.class, () ->
678 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
683 void testValidateCategorySizeBiggerThan1() {
684 Resource resource = createParseResourceObject(true);
685 List<CategoryDefinition> categories = new ArrayList<>();
686 CategoryDefinition categoryDefinition1 = new CategoryDefinition();
687 CategoryDefinition categoryDefinition2 = new CategoryDefinition();
688 categories.add(categoryDefinition1);
689 categories.add(categoryDefinition2);
691 resource.setCategories(categories);
692 Assertions.assertThrows(ComponentException.class, () ->
693 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
698 void testValidateEmptySubCategory() {
699 Resource resource = createParseResourceObject(true);
700 List<CategoryDefinition> categories = resource.getCategories();
701 CategoryDefinition categoryDefinition = categories.get(0);
702 categoryDefinition.setSubcategories(null);
704 Assertions.assertThrows(ComponentException.class, () ->
705 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
710 void testValidateEmptySubCategorySizeBiggerThan1() {
711 Resource resource = createParseResourceObject(true);
712 List<CategoryDefinition> categories = resource.getCategories();
713 CategoryDefinition categoryDefinition = categories.get(0);
714 List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
715 SubCategoryDefinition subCategoryDefinition1 = new SubCategoryDefinition();
716 SubCategoryDefinition subCategoryDefinition2 = new SubCategoryDefinition();
717 subcategories.add(subCategoryDefinition1);
718 subcategories.add(subCategoryDefinition2);
720 Assertions.assertThrows(ComponentException.class, () ->
721 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
726 void testValidateEmptyCategoryName() {
727 Resource resource = createParseResourceObject(true);
728 List<CategoryDefinition> categories = resource.getCategories();
729 CategoryDefinition categoryDefinition = categories.get(0);
730 categoryDefinition.setName(null);
732 Assertions.assertThrows(ComponentException.class, () ->
733 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
737 void testValidateEmptySubCategoryName() {
738 Resource resource = createParseResourceObject(true);
739 List<CategoryDefinition> categories = resource.getCategories();
740 CategoryDefinition categoryDefinition = categories.get(0);
741 List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
742 SubCategoryDefinition subCategoryDefinition1 = subcategories.get(0);
743 subCategoryDefinition1.setName(null);
745 Assertions.assertThrows(ComponentException.class, () ->
746 testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
750 void testValidateCategoryListed() {
751 Resource resource = createParseResourceObject(true);
752 CategoryDefinition category = resource.getCategories().get(0);
753 SubCategoryDefinition subcategory = category.getSubcategories().get(0);
754 Assertions.assertThrows(ComponentException.class, () ->
755 testSubject.validateCategoryListed(category, subcategory, user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
759 void testFailOnInvalidCategory() {
760 Resource resource = createParseResourceObject(true);
761 Assertions.assertThrows(ComponentException.class, () ->
762 testSubject.failOnInvalidCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
767 void testValidateVendorName() {
768 Resource resource = createParseResourceObject(true);
769 Assertions.assertNotNull(resource);
770 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
774 void testValidateVendorNameEmpty() {
775 Resource resource = createParseResourceObject(true);
776 resource.setVendorName(null);
777 Assertions.assertThrows(ComponentException.class, () ->
778 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
782 void testValidateVendorNameWrongLen() {
783 Resource resource = createParseResourceObject(true);
784 resource.setVendorName("000000000011122221111222333444443222556677788778889999998776554332340");
785 Assertions.assertThrows(ComponentException.class, () ->
786 testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
790 void testValidateVendorName2() {
791 Resource resource = createParseResourceObject(true);
792 CategoryDefinition category = resource.getCategories().get(0);
793 SubCategoryDefinition subcategory = category.getSubcategories().get(0);
794 String vendorName = "vendorName";
795 Assertions.assertNotNull(resource);
797 testSubject.validateVendorName(vendorName, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
801 void testFillResourceMetadata2() {
802 String yamlName = "yamlName";
803 Resource resourceVf = createParseResourceObject(true);
804 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
805 resourceVf.setSystemName("systemName");
806 Assertions.assertThrows(ComponentException.class, () ->
807 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
811 void testFillResourceMetadataWrongStart() {
812 String yamlName = "yamlName";
813 Resource resourceVf = createParseResourceObject(true);
814 String nodeName = "WrongStart" + "test";
815 Assertions.assertThrows(ComponentException.class, () ->
816 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
820 void testFillResourceMetadataResourceTypeIsAbs() {
821 String yamlName = "yamlName";
822 Resource resourceVf = createParseResourceObject(true);
823 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + Constants.ABSTRACT;
824 Assertions.assertNotNull(
825 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
829 void testGetNodeTypeActualName() {
830 String fullName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
831 Assertions.assertNotNull(
832 testSubject.getNodeTypeActualName(fullName));
836 void testAddInput() {
837 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
838 InputDefinition prop = new InputDefinition();
839 Assertions.assertNotNull(currPropertiesMap);
841 testSubject.addInput(currPropertiesMap, prop);
845 void testFindAviableRequirement() {
846 String uniqueId = "101929382910";
847 String regName = uniqueId;
848 String yamlName = uniqueId;
849 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
850 ComponentInstance currentCompInstance = new ComponentInstance();
852 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
853 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
854 RequirementDefinition requirementDefinition = new RequirementDefinition();
855 requirementDefinition.setName(uniqueId);
856 requirementDefinition.setMaxOccurrences("10");
857 requirementDefinition.setLeftOccurrences("3");
858 requirementDefinitionList.add(requirementDefinition);
859 requirements.put(uniqueId, requirementDefinitionList);
860 currentCompInstance.setRequirements(requirements);
862 String capName = "capName";
864 Assertions.assertNotNull(
865 testSubject.findAviableRequiremen(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
869 void testFindAviableRequirementSameCapName() {
870 String uniqueId = "101929382910";
871 String regName = uniqueId;
872 String yamlName = uniqueId;
873 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
874 ComponentInstance currentCompInstance = new ComponentInstance();
876 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
877 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
878 RequirementDefinition requirementDefinition = new RequirementDefinition();
879 requirementDefinition.setName(uniqueId);
880 requirementDefinition.setMaxOccurrences("10");
881 requirementDefinition.setLeftOccurrences("3");
882 requirementDefinitionList.add(requirementDefinition);
883 requirements.put(uniqueId, requirementDefinitionList);
884 currentCompInstance.setRequirements(requirements);
886 String capName = uniqueId;
887 Assertions.assertNotNull(
888 testSubject.findAviableRequiremen(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
892 void testFindAvailableCapabilityByTypeOrName() {
893 RequirementDefinition validReq = new RequirementDefinition();
894 ComponentInstance currentCapCompInstance = new ComponentInstance();
895 UploadReqInfo uploadReqInfo = new UploadReqInfo();
897 Assertions.assertThrows(ComponentException.class, () ->
898 testSubject.findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadReqInfo));
902 void testFindAvailableCapability() {
903 String uniqueId = "23422345677";
904 RequirementDefinition validReq = new RequirementDefinition();
905 validReq.setCapability(uniqueId);
906 ComponentInstance instance = new ComponentInstance();
907 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
908 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
909 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
910 capabilityDefinition.setMaxOccurrences("3");
911 capabilityDefinition.setLeftOccurrences("2");
912 capabilityDefinitionList.add(capabilityDefinition);
913 capabilityMap.put(uniqueId, capabilityDefinitionList);
914 instance.setCapabilities(capabilityMap);
916 Assertions.assertNotNull(
917 testSubject.findAvailableCapability(validReq, instance));
921 void testfindAvailableCapability2() {
922 String uniqueId = "23422345677";
923 RequirementDefinition validReq = new RequirementDefinition();
924 validReq.setCapability(uniqueId);
925 ComponentInstance instance = new ComponentInstance();
926 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
927 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
928 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
929 capabilityDefinition.setName(uniqueId);
930 capabilityDefinition.setMaxOccurrences("3");
931 capabilityDefinition.setLeftOccurrences("2");
932 capabilityDefinitionList.add(capabilityDefinition);
933 capabilityMap.put(uniqueId, capabilityDefinitionList);
934 instance.setCapabilities(capabilityMap);
935 UploadReqInfo uploadReqInfo = new UploadReqInfo();
936 uploadReqInfo.setCapabilityName(uniqueId);
938 Assertions.assertNotNull(
939 testSubject.findAvailableCapability(validReq, instance, uploadReqInfo));
943 void testGetComponentWithInstancesFilter() {
945 Assertions.assertNotNull(
946 testSubject.getComponentWithInstancesFilter());
950 void testCreateParseResourceObject() {
951 String key = "0923928394";
952 List<UploadCapInfo> capabilities = new ArrayList<>();
953 UploadCapInfo uploadCapInfo = new UploadCapInfo();
954 uploadCapInfo.setType(key);
955 capabilities.add(uploadCapInfo);
957 String resourceId = "resourceId";
958 Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
959 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
960 capabilityDefinition.setName(key);
961 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
962 capabilityDefinitionList.add(capabilityDefinition);
963 defaultCapabilities.put(key, capabilityDefinitionList);
965 Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
966 InputDefinition prop = new InputDefinition();
968 Resource resource = createParseResourceObject(true);
969 Map<String, List<CapabilityDefinition>> capabilitiesMap = resource.getCapabilities();
970 capabilitiesMap.put(key, capabilityDefinitionList);
972 when(toscaOperationFacade.getToscaFullElement(anyString()))
973 .thenReturn(Either.left(resource));
975 Assertions.assertNotNull(resource);
977 testSubject.addValidComponentInstanceCapabilities(key, capabilities, resourceId, defaultCapabilities,
978 validCapabilitiesMap);
982 void testGetCapabilityFailure() {
983 String resourceId = "resourceId";
984 String key = "0923928394";
985 Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
986 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
987 capabilityDefinition.setName(key);
988 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
989 capabilityDefinitionList.add(capabilityDefinition);
990 defaultCapabilities.put(key, capabilityDefinitionList);
991 String capabilityType = key;
992 when(toscaOperationFacade.getToscaFullElement(anyString()))
993 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
994 Assertions.assertThrows(ComponentException.class, () ->
995 testSubject.getCapability(resourceId, defaultCapabilities, capabilityType));
999 void testValidateCapabilityProperties() {
1000 List<UploadCapInfo> capabilities = new ArrayList<>();
1001 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1002 List<UploadPropInfo> properties = new ArrayList<>();
1003 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1004 properties.add(uploadPropInfo);
1005 uploadCapInfo.setProperties(properties);
1006 capabilities.add(uploadCapInfo);
1007 String resourceId = "resourceId";
1008 CapabilityDefinition defaultCapability = new CapabilityDefinition();
1009 defaultCapability.setProperties(null);
1010 defaultCapability.setName("test");
1012 Assertions.assertThrows(ComponentException.class, () ->
1013 testSubject.validateCapabilityProperties(capabilities, resourceId, defaultCapability));
1017 void testValidateUniquenessUpdateUploadedComponentInstanceCapability() {
1018 String key = "02124568";
1019 List<UploadCapInfo> capabilities = new ArrayList<>();
1020 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1021 List<UploadPropInfo> properties = new ArrayList<>();
1022 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1023 uploadPropInfo.setName(key);
1024 properties.add(uploadPropInfo);
1025 uploadCapInfo.setProperties(properties);
1026 capabilities.add(uploadCapInfo);
1027 String resourceId = "resourceId";
1028 CapabilityDefinition defaultCapability = new CapabilityDefinition();
1029 List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
1030 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
1031 componentInstancePropertyList.add(componentInstanceProperty);
1032 defaultCapability.setProperties(componentInstancePropertyList);
1033 defaultCapability.setName(key);
1035 Assertions.assertNotNull(defaultCapability);
1037 testSubject.validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, uploadCapInfo);
1041 void testSetDeploymentArtifactsPlaceHolderByResource() {
1042 Resource resource = createParseResourceObject(true);
1044 Assertions.assertNotNull(resource);
1046 testSubject.setDeploymentArtifactsPlaceHolder(resource, user);
1050 void testSetDeploymentArtifactsPlaceHolderByService() {
1051 Service Service = createServiceObject(true);
1053 Assertions.assertNotNull(Service);
1055 testSubject.setDeploymentArtifactsPlaceHolder(Service, user);
1059 void testProcessDeploymentResourceArtifacts() {
1060 Resource resource = createParseResourceObject(true);
1061 resource.setResourceType(ResourceTypeEnum.VF);
1062 Map<String, ArtifactDefinition> artifactMap = new HashMap<>();
1064 Object v = new Object();
1065 Map<String, List<String>> artifactDetails = new HashMap<>();
1066 List<String> artifactTypes = new ArrayList<>();
1067 artifactTypes.add(ResourceTypeEnum.VF.name());
1068 artifactDetails.put("validForResourceTypes", artifactTypes);
1069 v = artifactDetails;
1070 Assertions.assertNotNull(resource);
1072 testSubject.processDeploymentResourceArtifacts(user, resource, artifactMap, k, v);
1076 void testMergeOldResourceMetadataWithNew() {
1077 Resource oldResource = createParseResourceObject(true);
1078 Resource newResource = new Resource();
1080 Assertions.assertNotNull(oldResource);
1082 testSubject.mergeOldResourceMetadataWithNew(oldResource, newResource);
1086 void testBuildComplexVfcMetadata() {
1087 Resource resource = createParseResourceObject(true);
1088 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1089 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1090 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1091 List<String> derivedFrom = new ArrayList<>();
1092 derivedFrom.add("derivedFrom");
1093 nodeTypeInfo.setDerivedFrom(derivedFrom);
1094 nodesInfo.put(nodeName, nodeTypeInfo);
1096 Assertions.assertNotNull(
1097 testSubject.buildComplexVfcMetadata(getCsarInfo(), nodeName, nodesInfo));
1101 void testValidateResourceCreationFromNodeType() {
1102 Resource resource = createParseResourceObject(true);
1103 resource.setDerivedFrom(null);
1104 Assertions.assertThrows(ComponentException.class, () ->
1105 testSubject.validateResourceCreationFromNodeType(resource, user));
1109 void testCreateInputsOnResource() {
1110 Resource resource = createParseResourceObject(true);
1111 Map<String, InputDefinition> inputs = new HashMap<>();
1113 Assertions.assertNotNull(
1114 testSubject.createInputsOnResource(resource, inputs));
1118 void testCreateInputsOnResourceWhenIsNotEmpty() {
1119 String key = "12345667";
1120 Resource resource = createParseResourceObject(true);
1121 List<InputDefinition> inputDefinitionList = new ArrayList<>();
1122 InputDefinition inputDefinition = new InputDefinition();
1123 inputDefinitionList.add(inputDefinition);
1124 resource.setInputs(inputDefinitionList);
1125 Map<String, InputDefinition> inputs = new HashMap<>();
1126 inputs.put(key, inputDefinition);
1127 when(inputsBusinessLogic.createInputsInGraph(anyMap(),
1128 any(Component.class))).thenReturn(Either.left(inputDefinitionList));
1129 when(toscaOperationFacade
1130 .getToscaElement(anyString())).thenReturn(Either.left(resource));
1131 Assertions.assertNotNull(
1132 testSubject.createInputsOnResource(resource, inputs));
1136 void testCreateInputsOnService() {
1137 Service service = createServiceObject(true);
1138 List<InputDefinition> resourceProperties = new ArrayList<>();
1139 InputDefinition inputDefinition = new InputDefinition();
1140 inputDefinition.setName("inputDefinitionName");
1141 service.setInputs(resourceProperties);
1142 Map<String, InputDefinition> inputs = new HashMap<>();
1143 InputDefinition inputDefinitionMap = new InputDefinition();
1144 inputDefinition.setName("inputDefinitionName");
1145 inputs.put("inputsMap", inputDefinitionMap);
1146 List<InputDefinition> inputDefinitionList = new ArrayList<>();
1147 Service newService = new Service();
1149 when(inputsBusinessLogic.createInputsInGraph(any(Map.class), any(Component.class)))
1150 .thenReturn(Either.left(inputDefinitionList));
1151 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
1152 Service inputsOnService = testSubject.createInputsOnService(service, inputs);
1153 assertNotNull(inputsOnService);
1157 void testCreateServiceTransaction() {
1158 Service service = createServiceObject(true);
1159 List<ComponentInstance> list = new ArrayList<>();
1160 ComponentInstance componentInstance = new ComponentInstance();
1161 componentInstance.setName("name");
1162 service.setComponentInstances(list);
1163 when(toscaOperationFacade.validateComponentNameExists(
1164 anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class))).thenReturn(Either.left(false));
1166 when(toscaOperationFacade.createToscaComponent(any(Service.class))).thenReturn(Either.left(service));
1168 Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true));
1172 void testCreateArtifactsPlaceHolderData() {
1173 Service service = createServiceObject(true);
1174 CategoryDefinition category = new CategoryDefinition();
1175 category.setName("");
1176 List<CategoryDefinition> categories = new ArrayList<>();
1177 categories.add(category);
1178 service.setCategories(categories);
1179 Assertions.assertNotNull(service);
1181 testSubject.createArtifactsPlaceHolderData(service, user);
1186 void testSetInformationalArtifactsPlaceHolder() {
1187 Service service = createServiceObject(true);
1189 Assertions.assertNotNull(service);
1191 testSubject.setInformationalArtifactsPlaceHolder(service, user);
1196 void testValidateNestedDerivedFromDuringUpdate() {
1197 Resource currentResource = createParseResourceObject(true);
1198 Resource updateInfoResource = createParseResourceObject(true);
1199 String key = "2323456";
1201 List<String> currentDerivedFromList = new ArrayList<>();
1202 currentDerivedFromList.add(key);
1203 currentResource.setDerivedFrom(currentDerivedFromList);
1204 List<String> updatedDerivedFromList = new ArrayList<>();
1205 updatedDerivedFromList.add("23344567778");
1206 updateInfoResource.setDerivedFrom(updatedDerivedFromList);
1208 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1209 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1211 Assertions.assertNotNull(
1212 testSubject.validateNestedDerivedFromDuringUpdate(currentResource, updateInfoResource, true));
1217 void testValidateDerivedFromExtending() {
1218 Resource currentResource = createParseResourceObject(true);
1219 Resource updateInfoResource = createParseResourceObject(true);
1221 when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1222 .thenReturn(Either.left(false));
1224 Assertions.assertNotNull(
1225 testSubject.validateDerivedFromExtending(user, currentResource, updateInfoResource,
1226 AuditingActionEnum.IMPORT_RESOURCE));
1231 void testValidateResourceFieldsBeforeUpdate() {
1232 Resource currentResource = createParseResourceObject(true);
1233 Resource updateInfoResource = createParseResourceObject(true);
1235 Assertions.assertNotNull(currentResource);
1237 testSubject.validateResourceFieldsBeforeUpdate(currentResource, updateInfoResource, true, true);
1242 void testValidateResourceName() {
1243 Resource currentResource = createParseResourceObject(true);
1244 Resource updateInfoResource = createParseResourceObject(true);
1245 currentResource.setName("test1");
1246 updateInfoResource.setName("test2");
1248 Assertions.assertThrows(ComponentException.class, () ->
1249 testSubject.validateResourceName(currentResource, updateInfoResource, true, false));
1254 void testIsResourceNameEquals() {
1255 Resource currentResource = createParseResourceObject(true);
1256 Resource updateInfoResource = createParseResourceObject(true);
1258 boolean resourceNameEquals = testSubject.isResourceNameEquals(currentResource, updateInfoResource);
1259 assertTrue(resourceNameEquals);
1263 void testPrepareResourceForUpdate() {
1264 Resource oldResource = createParseResourceObject(true);
1265 Resource newResource = createParseResourceObject(true);
1266 when(lifecycleBusinessLogic.changeState(anyString(), any(User.class), any(LifeCycleTransitionEnum.class),
1267 any(LifecycleChangeInfoWithAction.class), anyBoolean(), anyBoolean())).thenReturn(Either.left(oldResource));
1269 Assertions.assertNotNull(
1270 testSubject.prepareResourceForUpdate(oldResource, newResource, user, true, true));
1275 void testFailOnChangeState() {
1276 ResponseFormat response = new ResponseFormat();
1277 Resource oldResource = createParseResourceObject(true);
1278 oldResource.setUniqueId("123");
1279 Resource newResource = createParseResourceObject(true);
1281 Assertions.assertThrows(ComponentException.class, () ->
1282 testSubject.failOnChangeState(response, user, oldResource, newResource));
1286 void testHandleResourceGenericType() {
1287 Resource resource = createParseResourceObject(true);
1289 Resource resource1 = testSubject.handleResourceGenericType(resource);
1290 assertNotEquals(resource, resource1);
1294 void testUpdateOrCreateGroups() {
1295 Resource resource = createParseResourceObject(true);
1296 Map<String, GroupDefinition> groups = new HashMap<>();
1297 Assertions.assertNotNull(resource);
1299 testSubject.updateOrCreateGroups(resource, groups);
1303 void testAddGroupsToCreateOrUpdate() {
1304 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1305 GroupDefinition groupDefinition = new GroupDefinition();
1306 groupDefinition.setInvariantName("groupDefinitionName");
1307 groupsFromResource.add(groupDefinition);
1308 List<GroupDefinition> groupsAsList = new ArrayList<>();
1309 GroupDefinition groupNewDefinition = getGroupDefinition();
1310 groupsAsList.add(groupNewDefinition);
1311 List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1312 List<GroupDefinition> groupsToCreate = new ArrayList<>();
1313 Assertions.assertNotNull(groupDefinition);
1315 testSubject.addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1319 void testAddGroupsToDelete() {
1320 List<GroupDefinition> groupsFromResource = new ArrayList<>();
1321 GroupDefinition groupDefinition = new GroupDefinition();
1322 groupDefinition.setName("groupDefinitionName");
1323 groupsFromResource.add(groupDefinition);
1324 List<GroupDefinition> groupsAsList = new ArrayList<>();
1325 GroupDefinition groupNewDefinition = new GroupDefinition();
1326 groupNewDefinition.setName("groupNewDefinitionName");
1327 groupsAsList.add(groupNewDefinition);
1328 List<GroupDefinition> groupsToDelete = new ArrayList<>();
1329 Assertions.assertNotNull(groupsFromResource);
1331 testSubject.addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1335 void testUpdateGroupsMembersUsingResource() {
1336 Service component = createServiceObject(true);
1337 Map<String, GroupDefinition> groups = new HashMap<>();
1338 GroupDefinition groupDefinition = getGroupDefinition();
1339 groupDefinition.setMembers(null);
1340 groups.put("groupsMap", groupDefinition);
1342 Assertions.assertNotNull(
1343 testSubject.updateGroupsMembersUsingResource(groups, component));
1347 void testupdateGroupMembers() {
1348 Service component = createServiceObject(true);
1349 Map<String, GroupDefinition> groups = new HashMap<>();
1350 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1351 List<ComponentInstance> componentInstances = new ArrayList<>();
1352 String groupName = "groupName";
1353 Map<String, String> members = new HashMap<>();
1355 Assertions.assertThrows(ComponentException.class, () ->
1356 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1360 void testupdateGroupMembersNotNull() {
1361 Service component = createServiceObject(true);
1362 Map<String, GroupDefinition> groups = getGroups();
1363 GroupDefinition updatedGroupDefinition = new GroupDefinition();
1364 List<ComponentInstance> componentInstances = new ArrayList<>();
1365 ComponentInstance componentInstance = new ComponentInstance();
1366 componentInstance.setName("componentInstanceName");
1367 componentInstance.setUniqueId("componentInstanceUniqueId");
1368 componentInstances.add(componentInstance);
1369 String groupName = "groupName";
1370 Map<String, String> members = new HashMap<>();
1371 members.put("members", "members");
1372 members.put("componentInstanceName", "members");
1374 Assertions.assertThrows(ComponentException.class, () ->
1375 testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1379 void testValidateCyclicGroupsDependencies() {
1380 Service component = createServiceObject(true);
1381 Map<String, GroupDefinition> groups = new HashMap<>();
1382 String key = "098738485";
1383 GroupDefinition groupDefinition = new GroupDefinition();
1384 groups.put(key, groupDefinition);
1386 Assertions.assertNotNull(
1387 testSubject.validateCyclicGroupsDependencies(groups));
1391 void testFillAllGroupMemebersRecursivly() {
1392 Map<String, GroupDefinition> allGroups = new HashMap<>();
1393 Set<String> allGroupMembers = new HashSet<>();
1394 String groupName = "groupName";
1395 Assertions.assertNotNull(groupName);
1397 testSubject.fillAllGroupMemebersRecursivly(groupName, allGroups, allGroupMembers);
1401 void testFillAllGroupMemebersRecursivlyAllGroups() {
1402 String groupName = "groupName";
1403 Map<String, GroupDefinition> allGroups = new HashMap<>();
1404 GroupDefinition groupDefinition = new GroupDefinition();
1405 Map<String, String> members = new HashMap<>();
1406 members.put("members", "members");
1407 groupDefinition.setMembers(members);
1408 allGroups.put(groupName, groupDefinition);
1409 allGroups.put("members", groupDefinition);
1410 Set<String> allGroupMembers = new HashSet<>();
1411 allGroupMembers.add("allGroupMembers");
1412 Assertions.assertNotNull(allGroups);
1414 testSubject.fillAllGroupMemebersRecursivly(groupName, allGroups, allGroupMembers);
1418 void testFillResourceMetadataForServiceFailure() {
1419 String yamlName = "yamlName";
1420 Service resourceVf = createServiceObject(true);
1421 String nodeName = "nodeName";
1423 Assertions.assertThrows(ComponentException.class, () ->
1424 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1428 void testFillResourceMetadataForServiceWrongType() {
1429 String yamlName = "yamlName";
1430 Service resourceVf = createServiceObject(true);
1431 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "nodeName";
1433 Assertions.assertThrows(ComponentException.class, () ->
1434 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1438 void testFillResourceMetadataForServiceSuccess() {
1439 String yamlName = "yamlName";
1440 Service resourceVf = createServiceObject(true);
1441 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "VFC";
1443 Assertions.assertNotNull(
1444 testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1448 void testpropagateStateToCertified() {
1449 String yamlName = "yamlName";
1450 Resource resource = createParseResourceObject(true);
1451 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1452 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1454 Assertions.assertNotNull(
1455 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1459 void testpropagateStateToCertifiedIsTrue() {
1460 String yamlName = "yamlName";
1461 Resource resource = createParseResourceObject(true);
1462 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1463 resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1465 Assertions.assertNotNull(
1466 testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1470 void testBuildValidComplexVfc2() {
1471 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1472 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1473 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1474 List<String> derivedFrom = new ArrayList<>();
1475 derivedFrom.add("derivedFrom");
1476 nodeTypeInfo.setDerivedFrom(derivedFrom);
1477 nodesInfo.put(nodeName, nodeTypeInfo);
1479 final CsarInfo csarInfo = getCsarInfo();
1480 Assertions.assertThrows(ComponentException.class, () ->
1481 testSubject.buildValidComplexVfc(csarInfo, nodeName, nodesInfo));
1485 void testUpdateGroupsOnResourceEmptyGroups() {
1486 Resource resource = createParseResourceObject(true);
1487 Map<String, GroupDefinition> groups = new HashMap<>();
1489 Assertions.assertNotNull(
1490 testSubject.updateGroupsOnResource(resource, groups));
1494 void testSetInformationalArtifactsPlaceHolder2() {
1495 Resource resource = createParseResourceObject(true);
1496 List<CategoryDefinition> categoryDefinitions = new ArrayList<>();
1497 CategoryDefinition categoryDefinition = new CategoryDefinition();
1498 categoryDefinition.setName("");
1499 categoryDefinitions.add(categoryDefinition);
1500 resource.setCategories(categoryDefinitions);
1501 Assertions.assertNotNull(resource);
1503 testSubject.setInformationalArtifactsPlaceHolder(resource, user);
1507 void testRollback() {
1508 Resource resource = createParseResourceObject(true);
1509 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1510 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1511 createdArtifacts.add(artifactDefinition);
1512 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1513 nodeTypesNewCreatedArtifacts.add(artifactDefinition);
1514 Assertions.assertNotNull(resource);
1516 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1520 void testRollback_NotNull() {
1521 Resource resource = createParseResourceObject(true);
1522 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1523 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1524 artifactDefinition.setArtifactName("artifactName");
1525 createdArtifacts.add(artifactDefinition);
1526 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1527 ArtifactDefinition artifactDefinition2 = new ArtifactDefinition();
1528 artifactDefinition2.setArtifactChecksum("artifactChecksum");
1529 nodeTypesNewCreatedArtifacts.add(artifactDefinition2);
1530 Assertions.assertNotNull(resource);
1532 testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1536 void testCreateArtifactsPlaceHolderData2() {
1537 Resource resource = createParseResourceObject(true);
1539 Assertions.assertNotNull(resource);
1541 testSubject.createArtifactsPlaceHolderData(resource, user);
1545 void testHandleGroupsProperties() {
1546 Service service = createServiceObject(true);
1547 Map<String, GroupDefinition> groups = getGroups();
1548 Assertions.assertNotNull(service);
1550 testSubject.handleGroupsProperties(service, groups);
1554 void testHandleGroupsProperties2() {
1555 Resource resource = createParseResourceObject(true);
1556 Map<String, GroupDefinition> groups = getGroups();
1557 Assertions.assertNotNull(resource);
1559 testSubject.handleGroupsProperties(resource, groups);
1563 void testHandleGetInputs() {
1564 PropertyDataDefinition property = new PropertyDataDefinition();
1565 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1566 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1567 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1568 getInput.setInputId("inputId");
1569 getInput.setInputName("inputName");
1570 getInputValueDataDefinition.setInputName("inputName");
1571 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1572 getInputValueDataDefinition.setGetInputIndex(getInputValueDataDefinition);
1573 getInputValues.add(getInputValueDataDefinition);
1574 property.setGetInputValues(getInputValues);
1575 List<InputDefinition> inputs = new ArrayList<>();
1576 InputDefinition inputDefinition = new InputDefinition();
1577 inputDefinition.setName("inputName");
1578 inputDefinition.setUniqueId("abc12345");
1579 inputs.add(inputDefinition);
1580 Assertions.assertNotNull(inputs);
1582 testSubject.handleGetInputs(property, inputs);
1586 void testHandleGetInputs_null() {
1587 PropertyDataDefinition property = new PropertyDataDefinition();
1588 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1589 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1590 getInputValueDataDefinition.setInputName("inputName");
1591 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1592 getInputValues.add(getInputValueDataDefinition);
1593 property.setGetInputValues(getInputValues);
1594 List<InputDefinition> inputs = new ArrayList<>();
1595 Assertions.assertThrows(NoSuchElementException.class, () ->
1596 testSubject.handleGetInputs(property, inputs));
1600 void testFindInputByName() {
1601 GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1602 getInput.setInputId("inputId");
1603 getInput.setInputName("inputName");
1604 List<InputDefinition> inputs = new ArrayList<>();
1605 InputDefinition inputDefinition = new InputDefinition();
1606 inputDefinition.setName("inputName");
1607 inputDefinition.setUniqueId("abc12345");
1608 inputs.add(inputDefinition);
1610 Assertions.assertNotNull(
1611 testSubject.findInputByName(inputs, getInput));
1615 void testAssociateComponentInstancePropertiesToComponent() {
1616 String yamlName = "yamlName";
1617 Resource resource = createParseResourceObject(true);
1618 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1619 Assertions.assertThrows(ComponentException.class, () ->
1620 testSubject.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties));
1624 void testAssociateComponentInstanceInputsToComponent() {
1625 String yamlName = "yamlName";
1626 Resource resource = createParseResourceObject(true);
1627 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1628 List<ComponentInstanceInput> componentInstanceInputList = new ArrayList<>();
1629 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1630 componentInstanceInput.setName("componentInstanceInputName");
1631 componentInstanceInputList.add(componentInstanceInput);
1632 Assertions.assertNotNull(resource);
1634 testSubject.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1638 void testAssociateDeploymentArtifactsToInstances() {
1639 String yamlName = "yamlName";
1640 Resource resource = createParseResourceObject(true);
1641 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1643 Assertions.assertThrows(ComponentException.class, () ->
1644 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1648 void testAssociateArtifactsToInstances() {
1649 String yamlName = "yamlName";
1650 Resource resource = createParseResourceObject(true);
1651 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1653 Assertions.assertThrows(ComponentException.class, () ->
1654 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1658 void testAssociateArtifactsToInstances2() {
1659 String yamlName = "yamlName";
1660 Resource resource = createParseResourceObject(true);
1661 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1663 Assertions.assertThrows(ComponentException.class, () ->
1664 testSubject.associateArtifactsToInstances(yamlName, resource, instDeploymentArtifacts));
1668 void testAssociateOrAddCalculatedCapReq() {
1669 String yamlName = "yamlName";
1670 Resource resource = createParseResourceObject(true);
1671 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1672 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1673 Assertions.assertThrows(ComponentException.class, () ->
1674 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1678 void testAssociateInstAttributeToComponentToInstances() {
1679 String yamlName = "yamlName";
1680 Resource resource = createParseResourceObject(true);
1681 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1682 Assertions.assertThrows(ComponentException.class, () ->
1683 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1687 void testThrowComponentExceptionByResource() {
1688 StorageOperationStatus status = StorageOperationStatus.OK;
1689 Resource resource = createParseResourceObject(true);
1690 Assertions.assertThrows(ComponentException.class, () ->
1691 testSubject.throwComponentExceptionByResource(status, resource));
1695 void testGetResourceAfterCreateRelations() {
1696 Resource resource = createParseResourceObject(true);
1697 Resource newResource = new Resource();
1699 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1700 .thenReturn(Either.left(newResource));
1701 Resource resourceAfterCreateRelations = testSubject.getResourceAfterCreateRelations(resource);
1702 assertNotNull(resourceAfterCreateRelations);
1706 void testSetCapabilityNamesTypes() {
1707 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1708 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1709 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1710 capabilityDefinition.setName("Capability");
1711 capabilityDefinition.setType("Resource");
1712 capabilityDefinitionList.add(capabilityDefinition);
1713 originCapabilities.put("Capability", capabilityDefinitionList);
1714 Map<String, List<UploadCapInfo>> uploadedCapabilities = new HashMap<>();
1715 List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
1716 UploadCapInfo uploadCapInfo = new UploadCapInfo();
1717 uploadCapInfoList.add(uploadCapInfo);
1718 uploadedCapabilities.put("Capability", uploadCapInfoList);
1719 Assertions.assertNotNull(originCapabilities);
1721 testSubject.setCapabilityNamesTypes(originCapabilities, uploadedCapabilities);
1725 void testAssociateComponentInstanceInputsToComponent2() {
1726 String yamlName = "yamlName";
1727 Service service = createServiceObject(true);
1728 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1730 Assertions.assertNotNull(service);
1732 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1736 void testAssociateComponentInstanceInputsNotNullToComponent2() {
1737 String yamlName = "yamlName";
1738 Service service = createServiceObject(true);
1739 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1740 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
1741 ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1742 componentInstanceInput.setName("ComponentInstanceInputName");
1743 componentInstanceInputs.add(componentInstanceInput);
1744 instInputs.put("instInputs", componentInstanceInputs);
1745 when(toscaOperationFacade.associateComponentInstanceInputsToComponent(any(Map.class),
1746 anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1747 Assertions.assertThrows(ComponentException.class, () ->
1748 testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs));
1752 void testAssociateComponentInstancePropertiesToComponent2() {
1753 String yamlName = "yamlName";
1754 Service service = createServiceObject(true);
1755 Map<String, List<ComponentInstanceProperty>> instInputs = new HashMap<>();
1756 Map<String, List<ComponentInstanceProperty>> instInputMap = new HashMap<>();
1757 when(toscaOperationFacade.associateComponentInstancePropertiesToComponent(any(), anyString()))
1758 .thenReturn(Either.left(instInputMap));
1759 Assertions.assertNotNull(service);
1761 testSubject.associateComponentInstancePropertiesToComponent(yamlName, service, instInputs);
1765 void testAssociateDeploymentArtifactsToInstances2() {
1766 String yamlName = "yamlName";
1767 Service service = createServiceObject(true);
1768 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1770 Assertions.assertThrows(ComponentException.class, () ->
1771 testSubject.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts));
1775 void testAssociateArtifactsToInstances3() {
1776 String yamlName = "yamlName";
1777 Service service = createServiceObject(true);
1778 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1780 Assertions.assertThrows(ComponentException.class, () ->
1781 testSubject.associateArtifactsToInstances(yamlName, service, instArtifacts));
1785 void testAssociateOrAddCalculatedCapReq2() {
1786 String yamlName = "yamlName";
1787 Service resource = createServiceObject(true);
1788 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1789 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1790 Assertions.assertThrows(ComponentException.class, () ->
1791 testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1795 void testAssociateInstAttributeToComponentToInstances2() {
1796 String yamlName = "yamlName";
1797 Service resource = createServiceObject(true);
1798 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1799 Assertions.assertThrows(ComponentException.class, () ->
1800 testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1804 void testAssociateRequirementsToService() {
1805 String yamlName = "yamlName";
1806 Service resource = createServiceObject(true);
1807 Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
1808 Assertions.assertThrows(ComponentException.class, () ->
1809 testSubject.associateRequirementsToService(yamlName, resource, requirements));
1813 void testAssociateCapabilitiesToService() {
1814 String yamlName = "yamlName";
1815 Service resource = createServiceObject(true);
1816 Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
1817 Assertions.assertThrows(ComponentException.class, () ->
1818 testSubject.associateCapabilitiesToService(yamlName, resource, capabilities));
1822 void testAssociateResourceInstances() {
1823 String yamlName = "yamlName";
1824 Service resource = createServiceObject(true);
1825 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1826 when(toscaOperationFacade.associateResourceInstances(any(Component.class),
1827 anyString(), any(ArrayList.class))).thenReturn(Either.left(relations));
1828 Assertions.assertNotNull(resource);
1830 testSubject.associateResourceInstances(yamlName, resource, relations);
1834 void testAddCapabilities() {
1835 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1836 String type = "type";
1837 List<CapabilityDefinition> capabilities = new ArrayList<>();
1838 Assertions.assertNotNull(type);
1840 testSubject.addCapabilities(originCapabilities, type, capabilities);
1844 void testAddCapabilitiesProperties() {
1845 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1846 List<UploadCapInfo> capabilities = new ArrayList<>();
1847 UploadCapInfo capability = new UploadCapInfo();
1848 List<UploadPropInfo> properties = new ArrayList<>();
1849 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1850 uploadPropInfo.setName("uploadPropInfoName");
1851 properties.add(uploadPropInfo);
1852 capability.setProperties(properties);
1853 capability.setName("capabilityName");
1854 capabilities.add(capability);
1855 Assertions.assertNotNull(capabilities);
1857 testSubject.addCapabilitiesProperties(newPropertiesMap, capabilities);
1861 void testGetServiceWithGroups() {
1862 String resourceId = "resourceId";
1863 Service service = createServiceObject(true);
1864 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1865 .thenReturn(Either.left(service));
1866 Assertions.assertNotNull(
1867 testSubject.getServiceWithGroups(resourceId));
1871 void testGetResourceWithGroups() {
1872 String resourceId = "resourceId";
1873 Resource resource = createParseResourceObject(false);
1874 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1875 .thenReturn(Either.left(resource));
1876 Assertions.assertNotNull(
1877 testSubject.getResourceWithGroups(resourceId));
1881 void testAssociateResourceInstances2() {
1882 String yamlName = "yamlName";
1883 Resource resource = createParseResourceObject(true);
1884 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1885 when(toscaOperationFacade.associateResourceInstances(any(Resource.class),
1886 anyString(), any(ArrayList.class))).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1887 Assertions.assertThrows(ComponentException.class, () ->
1888 testSubject.associateResourceInstances(yamlName, resource, relations));
1892 void testAddRelationsToRI() {
1893 String yamlName = "group.yml";
1894 Resource resource = createResourceObject(false);
1896 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1897 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1898 nodesInfoValue.getRequirements().get("requirements").get(0).setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1899 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1900 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1901 ComponentInstance componentInstance = new ComponentInstance();
1902 componentInstance.setName("zxjTestImportServiceAb");
1903 componentInstancesList.add(componentInstance);
1904 resource.setComponentInstances(componentInstancesList);
1905 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setLeftOccurrences("1");
1906 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setMaxOccurrences("1");
1907 componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setCapability("tosca.capabilities.Node");
1908 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1909 RequirementDefinition requirementDefinition = new RequirementDefinition();
1910 requirementDefinition.setOwnerId("1");
1911 requirementDefinition.setUniqueId("2");
1912 requirementDefinition.setCapability("3");
1913 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1914 capabilityDefinition.setName("4");
1915 capabilityDefinition.setUniqueId("5");
1916 capabilityDefinition.setOwnerId("6");
1917 ResponseFormat responseFormat = new ResponseFormat();
1918 responseFormat.setStatus(200);
1919 Assertions.assertNotNull(resource);
1921 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1925 void testAddRelationsToRI_null() {
1926 String yamlName = "group.yml";
1927 Resource resource = createParseResourceObject(true);
1928 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1929 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1930 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1931 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1932 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1934 Assertions.assertThrows(ComponentException.class, () ->
1935 testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList,
1940 void testAddRelationToRI() {
1941 String yamlName = "yamlName";
1942 Resource resource = createParseResourceObject(true);
1943 resource.setComponentInstances(creatComponentInstances());
1944 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1945 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1947 Assertions.assertNotNull(
1948 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1952 void testAddRelationToRI_null() {
1953 String yamlName = "yamlName.yml";
1954 Resource resource = createParseResourceObject(false);
1955 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1956 resource.setComponentInstances(componentInstancesList);
1957 UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1958 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1959 Assertions.assertNotNull(
1960 testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1964 void testFindVfcResource() {
1965 Service service = createServiceObject(true);
1966 String currVfcToscaName = "currVfcToscaName";
1967 String previousVfcToscaName = "previousVfcToscaName";
1968 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
1969 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1970 final CsarInfo csarInfo = getCsarInfo();
1971 Assertions.assertThrows(ComponentException.class, () ->
1972 testSubject.findVfcResource(csarInfo, service, currVfcToscaName, previousVfcToscaName,
1973 StorageOperationStatus.OK));
1976 private GroupDefinition getGroupDefinition() {
1977 GroupDefinition groupDefinition = new GroupDefinition();
1978 Map<String, String> members = new HashMap<>();
1979 members.put("members", "members");
1980 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1981 List<PropertyDataDefinition> properties = new ArrayList<>();
1982 groupDefinition.setInvariantName("groupDefinitionName");
1983 groupDefinition.setMembers(members);
1984 groupDefinition.setProperties(properties);
1985 groupDefinition.setCapabilities(capabilities);
1986 return groupDefinition;
1989 protected Resource createParseResourceObject(boolean afterCreate) {
1990 Resource resource = new Resource();
1991 resource.setName(RESOURCE_NAME);
1992 resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
1993 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
1994 resource.setDescription("My short description");
1995 List<String> tgs = new ArrayList<>();
1997 tgs.add(resource.getName());
1998 resource.setTags(tgs);
1999 List<String> template = new ArrayList<>();
2000 template.add("tosca.nodes.Root");
2001 resource.setDerivedFrom(template);
2002 resource.setVendorName("Motorola");
2003 resource.setVendorRelease("1.0.0");
2004 resource.setContactId("ya5467");
2005 resource.setIcon("defaulticon");
2006 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2007 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2008 requirements.put("test", requirementDefinitionList);
2009 resource.setRequirements(requirements);
2010 resource.setCost("cost");
2011 resource.setResourceVendorModelNumber("02312233");
2013 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2014 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2015 artifacts.put("artifact", artifactDefinition);
2016 resource.setArtifacts(artifacts);
2018 resource.setLicenseType("licType");
2021 resource.setName(resource.getName());
2022 resource.setVersion("0.1");
2023 resource.setUniqueId(resource.getName()
2024 .toLowerCase() + ":" + resource.getVersion());
2025 resource.setCreatorUserId(user.getUserId());
2026 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2027 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2032 protected CsarInfo getCsarInfo() {
2033 String csarUuid = "0010";
2034 User user = new User();
2035 Map<String, byte[]> csar = new HashMap<>();
2036 String vfReousrceName = "resouceName";
2037 String mainTemplateName = "mainTemplateName";
2038 String mainTemplateContent = null;
2040 mainTemplateContent = loadFileNameToJsonString("service_import_template.yml");
2041 } catch (IOException e) {
2042 e.printStackTrace();
2044 return new CsarInfo(user, csarUuid, csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
2047 private String loadFileNameToJsonString(String fileName) throws IOException {
2048 String sourceDir = "src/test/resources/normativeTypes";
2049 return loadFileNameToJsonString(sourceDir, fileName);
2052 private String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
2053 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
2054 byte[] fileContent = Files.readAllBytes(filePath);
2055 return new String(fileContent);
2058 protected Service createServiceObject(boolean afterCreate) {
2059 Service service = new Service();
2060 service.setUniqueId("sid");
2061 service.setName("Service");
2062 CategoryDefinition category = new CategoryDefinition();
2063 category.setName(SERVICE_CATEGORY);
2064 category.setIcons(Collections.singletonList("defaulticon"));
2065 List<CategoryDefinition> categories = new ArrayList<>();
2066 categories.add(category);
2067 service.setCategories(categories);
2068 service.setInstantiationType(INSTANTIATION_TYPE);
2070 service.setDescription("description");
2071 List<String> tgs = new ArrayList<>();
2072 tgs.add(service.getName());
2073 service.setTags(tgs);
2074 service.setIcon("defaulticon");
2075 service.setContactId("aa1234");
2076 service.setProjectCode("12345");
2077 service.setEcompGeneratedNaming(true);
2080 service.setVersion("0.1");
2081 service.setUniqueId(service.getName() + ":" + service.getVersion());
2082 service.setCreatorUserId(user.getUserId());
2083 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2088 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2089 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2090 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2091 assertParseResponse(actualResponse, expectedStatus, variables);
2094 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2095 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2096 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2097 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());