2 * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.openecomp.sdc.be.components.impl;
19 import static org.assertj.core.api.Java6Assertions.assertThat;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertNotNull;
22 import static org.junit.jupiter.api.Assertions.fail;
23 import static org.mockito.ArgumentMatchers.anyString;
24 import static org.mockito.Mockito.any;
25 import static org.mockito.Mockito.anyBoolean;
26 import static org.mockito.Mockito.anyList;
27 import static org.mockito.Mockito.anyMap;
28 import static org.mockito.Mockito.contains;
29 import static org.mockito.Mockito.doNothing;
30 import static org.mockito.Mockito.doReturn;
31 import static org.mockito.Mockito.eq;
32 import static org.mockito.Mockito.isNull;
33 import static org.mockito.Mockito.matches;
34 import static org.mockito.Mockito.mock;
35 import static org.mockito.Mockito.verify;
36 import static org.mockito.Mockito.when;
37 import static org.openecomp.sdc.be.components.impl.ServiceImportBusinessLogic.CREATE_RESOURCE;
39 import fj.data.Either;
41 import java.io.IOException;
42 import java.lang.reflect.InvocationTargetException;
43 import java.lang.reflect.Method;
44 import java.net.URISyntaxException;
45 import java.nio.file.FileSystems;
46 import java.nio.file.Files;
47 import java.nio.file.Path;
48 import java.nio.file.Paths;
49 import java.util.ArrayList;
50 import java.util.Collections;
51 import java.util.EnumMap;
52 import java.util.HashMap;
53 import java.util.List;
55 import java.util.Optional;
57 import org.apache.commons.codec.binary.Base64;
58 import org.apache.commons.collections.map.HashedMap;
59 import org.apache.commons.lang3.tuple.ImmutablePair;
60 import org.json.simple.JSONObject;
61 import org.junit.jupiter.api.Assertions;
62 import org.junit.jupiter.api.BeforeEach;
63 import org.junit.jupiter.api.Test;
64 import org.mockito.ArgumentCaptor;
65 import org.mockito.InjectMocks;
66 import org.mockito.MockitoAnnotations;
67 import org.openecomp.sdc.be.components.csar.CsarInfo;
68 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
69 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
70 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
71 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
72 import org.openecomp.sdc.be.dao.api.ActionStatus;
73 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
74 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
76 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
77 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
79 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
80 import org.openecomp.sdc.be.externalapi.servlet.ArtifactExternalServlet;
81 import org.openecomp.sdc.be.impl.ServletUtils;
82 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
83 import org.openecomp.sdc.be.model.ArtifactDefinition;
84 import org.openecomp.sdc.be.model.AttributeDefinition;
85 import org.openecomp.sdc.be.model.CapabilityDefinition;
86 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
87 import org.openecomp.sdc.be.model.Component;
88 import org.openecomp.sdc.be.model.ComponentInstance;
89 import org.openecomp.sdc.be.model.ComponentInstanceInput;
90 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
91 import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
92 import org.openecomp.sdc.be.model.ComponentParametersView;
93 import org.openecomp.sdc.be.model.DataTypeDefinition;
94 import org.openecomp.sdc.be.model.GroupDefinition;
95 import org.openecomp.sdc.be.model.GroupTypeDefinition;
96 import org.openecomp.sdc.be.model.IPropertyInputCommon;
97 import org.openecomp.sdc.be.model.InputDefinition;
98 import org.openecomp.sdc.be.model.InterfaceDefinition;
99 import org.openecomp.sdc.be.model.LifecycleStateEnum;
100 import org.openecomp.sdc.be.model.NodeTypeInfo;
101 import org.openecomp.sdc.be.model.Operation;
102 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
103 import org.openecomp.sdc.be.model.PolicyDefinition;
104 import org.openecomp.sdc.be.model.PropertyDefinition;
105 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
106 import org.openecomp.sdc.be.model.RequirementDefinition;
107 import org.openecomp.sdc.be.model.Resource;
108 import org.openecomp.sdc.be.model.Service;
109 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
110 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
111 import org.openecomp.sdc.be.model.UploadPropInfo;
112 import org.openecomp.sdc.be.model.UploadReqInfo;
113 import org.openecomp.sdc.be.model.UploadResourceInfo;
114 import org.openecomp.sdc.be.model.User;
115 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
116 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
117 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
118 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
119 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
120 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
121 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
122 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
123 import org.openecomp.sdc.be.servlets.AbstractValidationsServlet;
124 import org.openecomp.sdc.be.tosca.CsarUtils;
125 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
126 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
127 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
128 import org.openecomp.sdc.common.api.Constants;
129 import org.openecomp.sdc.common.zip.ZipUtils;
130 import org.openecomp.sdc.common.zip.exception.ZipException;
131 import org.openecomp.sdc.exception.ResponseFormat;
132 import org.yaml.snakeyaml.Yaml;
134 class ServiceImportBusinessLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
136 private final ArtifactDefinition artifactDefinition = mock(ArtifactDefinition.class);
137 private final ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
138 private final ServletUtils servletUtils = mock(ServletUtils.class);
139 private final AbstractValidationsServlet servlet = new ArtifactExternalServlet(
140 componentInstanceBusinessLogic, componentsUtils, servletUtils, resourceImportManager, artifactsBusinessLogic);
141 private final ApplicationDataTypeCache applicationDataTypeCache = mock(ApplicationDataTypeCache.class);
142 private final ArtifactTypeOperation artifactTypeOperation = mock(ArtifactTypeOperation.class);
143 private final DataTypeBusinessLogic dataTypeBusinessLogic = mock(DataTypeBusinessLogic.class);
144 private final ArtifactTypeImportManager artifactTypeImportManager = mock(ArtifactTypeImportManager.class);
145 private final GroupTypeOperation groupTypeOperation = mock(GroupTypeOperation.class);
146 private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
147 private final CapabilityTypeImportManager capabilityTypeImportManager = mock(CapabilityTypeImportManager.class);
148 private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager = mock(InterfaceLifecycleTypeImportManager.class);
151 private ServiceImportBusinessLogic sIBL;
153 public static String loadFileNameToJsonString(String fileName) throws IOException {
154 String sourceDir = "src/test/resources/normativeTypes";
155 return loadFileNameToJsonString(sourceDir, fileName);
158 private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
159 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
160 byte[] fileContent = Files.readAllBytes(filePath);
161 return new String(fileContent);
166 MockitoAnnotations.openMocks(this);
167 when(artifactDefinition.getMandatory()).thenReturn(true);
168 when(artifactDefinition.getArtifactName()).thenReturn("creatorFullName");
169 when(artifactDefinition.getArtifactType()).thenReturn("TOSCA_CSAR");
173 void testCreateService_OK() {
174 Service oldService = createServiceObject(true);
175 oldService.setComponentInstances(creatComponentInstances());
176 oldService.setComponentInstancesProperties(
177 Collections.singletonMap(COMPONENT_ID, Collections.singletonList(new ComponentInstanceProperty())));
178 String payloadName = "valid_vf";
179 Map<String, byte[]> payload = crateCsarFromPayload();
180 Service newService = createServiceObject(true);
181 newService.setComponentInstances(creatComponentInstances());
182 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
183 componentInstanceProperty.setName("propertiesName");
184 final JSONObject jsonObject = new JSONObject();
185 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), "zxjTestImportServiceAb_propertiesName");
186 componentInstanceProperty.setValue(jsonObject.toJSONString());
188 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
189 ArtifactDefinition artifactDef = new ArtifactDefinition();
190 String artifactUniqueId = "test_extcp_resource.assettoscatemplate";
191 artifactDef.setUniqueId(artifactUniqueId);
192 toscaArtifacts.put(ToscaExportHandler.ASSET_TOSCA_TEMPLATE, artifactDef);
193 Resource resource = new Resource();
194 String resourceUniqueId = "extcp_resource";
195 resource.setUniqueId(resourceUniqueId);
196 resource.setToscaArtifacts(toscaArtifacts);
197 resource.getComponentMetadataDefinition().getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
198 resource.setResourceType(ResourceTypeEnum.VF);
200 ImmutablePair<String, byte[]> resourceTemplate = getNodeType();
201 String updatedNodeType = "org.openecomp.resource.cp.extCP";
202 resource.setToscaResourceName(updatedNodeType);
204 newService.setComponentInstancesProperties(
205 Collections.singletonMap(COMPONENT_ID + "." + "zxjTestImportServiceAb", Collections.singletonList(componentInstanceProperty)));
206 newService.setProperties(getProperties());
208 when(serviceBusinessLogic.validateServiceBeforeCreate(eq(newService), any(User.class), any(AuditingActionEnum.class)))
209 .thenReturn(Either.left(newService));
210 when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
211 ServiceCsarInfo csarInfo = getCsarInfo();
212 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(csarInfo);
213 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
214 .thenReturn(Either.left(new HashMap<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>>()));
215 doReturn(getParsedToscaYamlInfo()).when(csarBusinessLogic).getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), any(), any(Service.class));
216 doReturn(getParsedToscaYamlInfo()).when(csarBusinessLogic).getParsedToscaYamlInfo(any(ServiceCsarInfo.class), any(Service.class));
217 when(serviceBusinessLogic.lockComponentByName(newService.getSystemName(), oldService, CREATE_RESOURCE)).thenReturn(Either.left(true));
218 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
219 when(serviceImportParseLogic.createServiceTransaction(oldService, csarInfo.getModifier(), false, AuditingActionEnum.CREATE_RESOURCE)).thenReturn(newService);
220 when(serviceImportParseLogic.createInputsOnService(eq(oldService), anyMap())).thenReturn(newService);
221 Assertions.assertDoesNotThrow(() -> {
222 when(serviceImportParseLogic.createSubstitutionFilterOnService(eq(oldService), any())).thenReturn(newService);
224 when(serviceImportParseLogic.getNodeTypesFromTemplate(anyMap())).thenReturn(getNodeTypes());
225 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class), anyMap(), any(Service.class),
226 anyBoolean(), any(), anyList(), anyBoolean(), any(CsarInfo.class), anyBoolean())).thenReturn(
227 new ImmutablePair<>(resource, ActionStatus.OK));
228 when(serviceImportParseLogic.getComponentWithInstancesFilter()).thenReturn(new ComponentParametersView());
229 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
230 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(new ComponentParametersView());
231 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
232 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
233 any(ComponentInstance.class), anyString())).thenReturn(Either.left(new RequirementDefinition()));
234 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class), any(ComponentInstance.class),
235 any(UploadReqInfo.class))).thenReturn(new CapabilityDefinition());
236 when(componentsUtils.getResponseFormat(eq(ActionStatus.OK), anyString())).thenReturn(new ResponseFormat(200));
237 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
238 doNothing().when(compositionBusinessLogic).setPositionsForComponentInstances(any(Service.class), anyString());
239 when(groupBusinessLogic.validateUpdateVfGroupNames(anyMap(), anyString())).thenReturn(Either.left(new HashMap<>()));
240 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean()))
241 .thenReturn(Either.left(newService));
242 when(serviceImportParseLogic.getServiceWithGroups(anyString())).thenReturn(newService);
243 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
244 when(graphLockOperation.unlockComponentByName(anyString(), anyString(), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
245 when(serviceImportParseLogic.createOutputsOnService(any(Service.class), any(), anyString())).thenReturn(newService);
246 when(toscaOperationFacade.updateInputsToComponent(anyList(), eq(newService.getUniqueId()))).thenReturn(Either.left(new ArrayList<>()));
248 when(applicationDataTypeCache.get(any(), contains("tosca.datatypes.test_"))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
249 DataTypeDefinition typeToBeUpdated = new DataTypeDefinition();
250 List<PropertyDefinition> properties = new ArrayList<>();
251 PropertyDefinition nameProperty = new PropertyDefinition();
252 nameProperty.setName("name");
253 nameProperty.setType("string");
254 properties.add(nameProperty);
255 PropertyDefinition versionProperty = new PropertyDefinition();
256 versionProperty.setName("version");
257 versionProperty.setType("string");
258 properties.add(versionProperty);
259 typeToBeUpdated.setProperties(properties);
260 when(applicationDataTypeCache.get(any(), eq("onap.datatypes.ToscaConceptIdentifier.datatype"))).thenReturn(Either.left(typeToBeUpdated));
261 when(applicationDataTypeCache.get(any(), matches("^((?!(tosca.datatypes.test_|onap.datatypes.ToscaConceptIdentifier)).)*$"))).thenReturn(Either.left(new DataTypeDefinition()));
263 when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.testartifacts.Name"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
264 when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.artifacts"))).thenReturn(Either.left(null));
266 when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces"))).thenReturn(Either.left(new InterfaceDefinition()));
267 when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces.test"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
270 when(capabilityTypeOperation.getCapabilityType(anyString()))
271 .thenReturn(Either.left(new CapabilityTypeDefinition()));
272 when(capabilityTypeOperation.getCapabilityType(contains("tosca.testcapabilitytypes.Name")))
273 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
275 when(toscaOperationFacade.getLatestByToscaResourceName(contains("org.openecomp.resource"), isNull()))
276 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
277 when(toscaOperationFacade.getLatestByToscaResourceName(contains("tosca.nodes."), isNull()))
278 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
279 when(toscaOperationFacade.getLatestByToscaResourceName(updatedNodeType, null)).thenReturn(Either.left(resource));
280 when(artifactsBusinessLogic.handleDownloadRequestById(resourceUniqueId, artifactUniqueId, user.getUserId(), ComponentTypeEnum.RESOURCE, null, null))
281 .thenReturn(resourceTemplate);
282 when(toscaOperationFacade.updatePropertyOfComponent(eq(oldService), any(PropertyDefinition.class))).thenReturn(Either.left(null));
283 when(toscaOperationFacade.updateComponentInstancePropsToComponent(anyMap(), anyString())).thenReturn(Either.left(null));
284 when(groupTypeOperation.getGroupTypeByUid(anyString())).thenReturn(Either.left(new GroupTypeDefinition()));
286 Service result = sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
287 assertNotNull(result);
288 assertNotNull(result.getComponentInstances());
289 assertEquals(1, result.getComponentInstances().size());
290 assertNotNull(result.getComponentInstances().get(0));
291 assertNotNull(result.getComponentInstances().get(0).getCapabilities());
292 assertEquals(1, result.getComponentInstances().get(0).getCapabilities().size());
293 assertNotNull(result.getComponentInstances().get(0).getRequirements());
294 assertEquals(1, result.getComponentInstances().get(0).getRequirements().size());
295 assertNotNull(result.getCategories());
296 assertEquals(1, result.getCategories().size());
298 ArgumentCaptor<String> yaml = ArgumentCaptor.forClass(String.class);
299 verify(dataTypeBusinessLogic).createDataTypeFromYaml(yaml.capture(), isNull(), anyBoolean());
300 Map<String, Object> yamlMap = new Yaml().load(yaml.getValue());
301 assertEquals(3, yamlMap.size());
302 assertNotNull(yamlMap.get("tosca.datatypes.test_a"));
303 assertNotNull(yamlMap.get("tosca.datatypes.test_b"));
304 assertNotNull(yamlMap.get("onap.datatypes.ToscaConceptIdentifier"));
306 ArgumentCaptor<String> artifactTypes = ArgumentCaptor.forClass(String.class);
307 verify(artifactTypeImportManager).createArtifactTypes(artifactTypes.capture(),isNull(), anyBoolean());
308 Map<String, Object> artifactTypesMap = new Yaml().load(artifactTypes.getValue());
309 assertEquals(1, artifactTypesMap.size());
310 assertNotNull(artifactTypesMap.get("tosca.testartifacts.Name"));
312 ArgumentCaptor<String> capabilityTypes = ArgumentCaptor.forClass(String.class);
313 verify(capabilityTypeImportManager).createCapabilityTypes(
314 capabilityTypes.capture(),
317 Map<String, Object> capabilityTypesMap = new Yaml().load(capabilityTypes.getValue());
318 assertEquals(1, capabilityTypesMap.size());
319 assertNotNull(capabilityTypesMap.get("tosca.testcapabilitytypes.Name"));
321 ArgumentCaptor<Map<String, Object>> nodeTypes = ArgumentCaptor.forClass(Map.class);
322 verify(resourceImportManager).importAllNormativeResource(nodeTypes.capture(), any(), any(), any(), any(),
323 anyBoolean(), anyBoolean());
324 Map<String, Object> nodeTypesMap = nodeTypes.getValue();
325 Map<String, Object> newUpdatedNodeType = (Map<String, Object>) nodeTypesMap.get(updatedNodeType);
326 assertEquals(8, ((Map<String, Object>) newUpdatedNodeType.get("properties")).size());
327 Assertions.assertNull(newUpdatedNodeType.get("attributes"));
328 assertEquals(3, ((List<Map<String, Object>>) newUpdatedNodeType.get("requirements")).size());
329 assertEquals(1, ((Map<String, Object>) newUpdatedNodeType.get("capabilities")).size());
330 assertEquals(2, ((Map<String, Object>) newUpdatedNodeType.get("interfaces")).size());
332 ArgumentCaptor<String> interfaceTypes = ArgumentCaptor.forClass(String.class);
333 verify(interfaceLifecycleTypeImportManager).createLifecycleTypes(interfaceTypes.capture(), any(), anyBoolean());
334 Map<String, Object> yamlInterfaceMap = new Yaml().load(interfaceTypes.getValue());
335 assertEquals(3, yamlInterfaceMap.size());
336 assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Attach"));
337 assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Detach"));
338 assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Reconfigure"));
343 void testCreateService_Fail_NotFoundNodeTypesArtifacts() {
344 Service oldService = createServiceObject(true);
345 String payloadName = "valid_vf";
346 Map<String, byte[]> payload = crateCsarFromPayload();
347 Service newService = createServiceObject(true);
349 when(serviceBusinessLogic.validateServiceBeforeCreate(any(Service.class), any(User.class), any(AuditingActionEnum.class)))
350 .thenReturn(Either.left(newService));
351 when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
352 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(getCsarInfo());
353 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
354 .thenReturn(Either.right(ActionStatus.GENERAL_ERROR));
355 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), anyString(),
356 any(Service.class))).thenReturn(getParsedToscaYamlInfo());
358 Assertions.assertThrows(ComponentException.class,
359 () -> sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName));
363 void testCreateServiceFromCsar() {
364 Service oldService = createServiceObject(true);
365 String csarUUID = "valid_vf";
366 Map<String, byte[]> payload = crateCsarFromPayload();
367 ServiceCsarInfo csarInfo = getCsarInfo();
368 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> map =
371 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class),
372 any(Map.class), anyString(), any())).thenReturn(csarInfo);
373 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class),
374 any(Service.class))).thenReturn(Either.left(map));
375 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromCsar(oldService,
376 user, payload, csarUUID, null));
380 void testCreateServiceFromYaml() {
381 Service oldService = createServiceObject(true);
382 Resource resource = createOldResource();
383 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
384 String yamlName = "group.yml";
385 ServiceCsarInfo csarInfo = getCsarInfo();
386 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
387 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
389 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
390 Map<String, Object> map = new HashMap<>();
391 map.put("tosca_definitions_version", "123");
392 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
393 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
394 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
395 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(Map.class),
396 eq(csarInfo), anyString(), any(Component.class))).thenReturn(parsedToscaYamlInfo);
397 when(serviceBusinessLogic.lockComponentByName(anyString(), any(Service.class), anyString()))
398 .thenReturn(Either.left(true));
400 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromYaml(oldService,
401 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
402 nodeTypesArtifactsToCreate, false, true, nodeName, user.getUserId(), null));
406 void testCreateServiceAndRIsFromYaml() {
407 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
408 Service oldService = createServiceObject(true);
409 Resource resource = createOldResource();
410 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
411 CreateServiceFromYamlParameter csfyp = getCsfyp();
412 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
413 Map<String, Object> map = new HashMap<>();
414 map.put("tosca_definitions_version", "123");
415 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
416 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
417 csfyp.setNodeTypesInfo(nodeTypesInfo);
418 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
419 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
420 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
421 false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId(), null));
425 void testCreateServiceAndRIsFromYamlShoudLook() {
426 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
427 Service oldService = createServiceObject(true);
428 Resource resource = createOldResource();
429 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
430 CreateServiceFromYamlParameter csfyp = getCsfyp();
431 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
432 Map<String, Object> map = new HashMap<>();
433 map.put("tosca_definitions_version", "123");
434 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
435 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
436 csfyp.setNodeTypesInfo(nodeTypesInfo);
437 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
438 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
439 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
440 false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId(), null));
444 void testCreateOrUpdateArtifacts() {
445 ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
446 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
447 String yamlFileName = "group.yml";
448 CsarInfo csarInfo = getCsarInfo();
449 Resource preparedResource = createParseResourceObject(false);
450 preparedResource.setResourceType(ResourceTypeEnum.VF);
451 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
452 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
453 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
454 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
455 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
456 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
457 artifactDefinition.setArtifactName("artifactName");
458 artifactDefinitions.add(artifactDefinition);
459 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
460 artifactDefinitions);
461 nodeTypesArtifactsToHandle.put(nodeName, enumListEnumMap);
462 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
463 nodeTypeInfoToUpdateArtifacts.setNodeName(nodeName);
464 nodeTypeInfoToUpdateArtifacts.setNodeTypesArtifactsToHandle(nodeTypesArtifactsToHandle);
466 Assertions.assertNotNull(
467 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
468 preparedResource, nodeTypeInfoToUpdateArtifacts, true, true)
473 void testHandleVfCsarArtifacts() {
474 Resource resource = createParseResourceObject(true);
475 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
476 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
477 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
478 artifactDefinition.setUniqueId("uniqueId");
479 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
480 resource.setDeploymentArtifacts(deploymentArtifacts);
481 CsarInfo csarInfo = getCsarInfo();
482 Map<String, byte[]> csar = new HashMap<>();
483 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
484 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
485 csar.put(csarKey, artifactsMetaBytes);
486 csarInfo.setCsar(csar);
487 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
488 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
489 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
490 when(csarArtifactsAndGroupsBusinessLogic
491 .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
492 anyList())).thenReturn(Either.left(resource));
493 Assertions.assertNotNull(
494 sIBL.handleVfCsarArtifacts(resource,
495 csarInfo, createdArtifacts, artifactOperation, true, true));
499 void testHandleVfCsarArtifactsGetToscaElement() {
500 Resource resource = createParseResourceObject(true);
501 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
502 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
503 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
504 artifactDefinition.setUniqueId("uniqueId");
505 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
506 resource.setDeploymentArtifacts(deploymentArtifacts);
507 CsarInfo csarInfo = getCsarInfo();
508 Map<String, byte[]> csar = new HashMap<>();
509 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
510 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
511 csar.put(csarKey, artifactsMetaBytes);
512 csarInfo.setCsar(csar);
513 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
514 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
515 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
516 when(csarArtifactsAndGroupsBusinessLogic
517 .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
518 anyList())).thenReturn(Either.left(resource));
519 Assertions.assertNotNull(
520 sIBL.handleVfCsarArtifacts(resource,
521 csarInfo, createdArtifacts, artifactOperation, true, true));
525 void testCreateOrUpdateSingleNonMetaArtifactToComstants() {
526 Resource resource = createParseResourceObject(false);
527 CsarInfo csarInfo = getCsarInfo();
528 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
529 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
530 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
531 artifactDefinition.setArtifactName("artifactDefinition");
532 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
533 resource.setDeploymentArtifacts(deploymentArtifacts);
534 Assertions.assertNotNull(resource);
535 Assertions.assertNotNull(csarInfo);
536 sIBL.createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, true, true);
541 void testCreateOrUpdateNonMetaArtifacts() {
542 CsarInfo csarInfo = getCsarInfo();
543 Resource resource = createParseResourceObject(false);
544 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
545 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
547 Either<Resource, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo, resource,
548 createdArtifacts, true, true, artifactOperation);
549 assertEquals(result.left().value(), resource);
553 void testFindVfCsarArtifactsToHandle() {
554 Resource resource = createParseResourceObject(false);
555 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
556 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
557 artifactDefinition.setArtifactName("artifactDefinition");
558 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
559 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
560 artifacts.put("artifacts", artifactDefinition);
561 List<GroupDefinition> groups = new ArrayList<>();
562 GroupDefinition groupDefinition = new GroupDefinition();
563 groupDefinition.setUniqueId("groupDefinitionUniqueId");
564 groupDefinition.setName("groupDefinition");
565 groups.add(groupDefinition);
566 resource.setDeploymentArtifacts(deploymentArtifacts);
567 resource.setArtifacts(artifacts);
568 resource.setGroups(groups);
569 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
571 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
572 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(resource, artifactPathAndNameList, user);
573 assertNotNull(result.left().value());
577 void testOrganizeVfCsarArtifactsByArtifactOperation() {
578 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
579 artifactPathAndNameList.add(getNonMetaArtifactInfo());
580 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
581 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
582 artifactDefinition.setArtifactName("artifactName");
583 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
584 artifactDefinition.setArtifactChecksum("artifactChecksum");
585 existingArtifactsToHandle.add(artifactDefinition);
586 Resource resource = createParseResourceObject(false);
588 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
589 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
590 existingArtifactsToHandle,
592 assertNotNull(enumMapResponseFormatEither.left().value());
596 void testOrganizeVfCsarArtifactsByArtifactOperationElse() {
597 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
598 artifactPathAndNameList.add(getNonMetaArtifactInfo());
599 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
600 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
601 artifactDefinition.setArtifactName("artifactName");
602 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
603 artifactDefinition.setArtifactChecksum("artifactChecksum");
604 existingArtifactsToHandle.add(artifactDefinition);
605 Resource resource = createParseResourceObject(false);
606 Assertions.assertNotNull(
607 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource,
612 void testProcessCsarArtifacts() {
613 CsarInfo csarInfo = getCsarInfo();
614 Resource resource = createParseResourceObject(false);
615 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
616 Either<Resource, ResponseFormat> resStatus = Either.left(resource);
617 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
618 artifactPathAndNameList.add(getNonMetaArtifactInfo());
619 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
620 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
621 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactPathAndNameList);
622 Assertions.assertNotNull(
623 sIBL.processCsarArtifacts(csarInfo,
624 resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
628 void testCreateOrUpdateSingleNonMetaArtifact() {
629 Resource resource = createParseResourceObject(false);
630 CsarInfo csarInfo = getCsarInfo();
631 Map<String, byte[]> csar = csarInfo.getCsar();
632 String rootPath = System.getProperty("user.dir");
634 byte[] data = new byte[0];
635 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
637 data = Files.readAllBytes(path);
638 } catch (IOException e) {
641 csar.put("valid_vf.csar", data);
642 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
643 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
644 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
645 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
646 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
647 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
648 artifactDefinition.setArtifactName("artifactName");
649 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
650 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Resource.class), any(User.class),
651 any(Map.class), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
652 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
653 .thenReturn(Either.left(artifactDefinition));
654 Assertions.assertNotNull(
655 sIBL.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath,
656 artifactFileName, artifactType, artifactGroupType, artifactLabel,
657 artifactDisplayName, artifactDescription, artifactId, artifactOperation,
658 createdArtifacts, true, true, true));
662 void testCreateOrUpdateServiceArtifacts() throws IOException {
663 ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
664 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
665 String yamlFileName = "group.yml";
666 CsarInfo csarInfo = getCsarInfo();
667 Map<String, byte[]> csar = new HashMap<>();
668 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
669 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
670 csar.put(csarKey, artifactsMetaBytes);
671 csarInfo.setCsar(csar);
672 Service preparedService = createServiceObject(true);
673 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
674 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
675 artifactDefinition.setArtifactName("artifactDefinition");
676 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
677 preparedService.setDeploymentArtifacts(deploymentArtifacts);
679 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(createServiceObject(true)));
680 when(csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
681 anyString(), anyString(), anyList(), anyBoolean(), anyBoolean())).thenReturn(Either.left(preparedService));
682 Assertions.assertNotNull(
683 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
684 preparedService, true, true));
688 void testHandleVfCsarServiceArtifacts() {
689 Service service = createServiceObject(true);
690 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
691 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
692 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
693 artifactDefinition.setUniqueId("uniqueId");
694 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
695 service.setDeploymentArtifacts(deploymentArtifacts);
696 CsarInfo csarInfo = getCsarInfo();
697 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
698 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
699 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
700 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean())).thenReturn(
701 Either.left(service));
702 Assertions.assertNotNull(
703 sIBL.handleVfCsarArtifacts(service, csarInfo, createdArtifacts, artifactOperation, true, true));
707 void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
708 Service service = createServiceObject(true);
709 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
710 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
711 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
712 artifactDefinition.setUniqueId("uniqueId");
713 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
714 service.setDeploymentArtifacts(deploymentArtifacts);
715 CsarInfo csarInfo = getCsarInfo();
716 Map<String, byte[]> csar = new HashMap<>();
717 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
718 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
719 csar.put(csarKey, artifactsMetaBytes);
720 csarInfo.setCsar(csar);
721 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
722 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
723 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
724 when(csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
725 anyString(), anyString(), anyList())).thenReturn(Either.left(service));
726 Assertions.assertNotNull(
727 sIBL.handleVfCsarArtifacts(service,
728 csarInfo, createdArtifacts, artifactOperation, true, true));
732 void testCreateOrUpdateNonMetaServiceArtifacts() {
733 CsarInfo csarInfo = getCsarInfo();
734 Service service = createServiceObject(true);
735 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
736 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
738 Either<Service, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo,
739 service, createdArtifacts, true, true, artifactOperation);
740 assertEquals(result.left().value(), service);
744 void testFindServiceCsarArtifactsToHandle() {
745 Service service = createServiceObject(true);
746 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
747 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
748 artifactDefinition.setArtifactName("artifactDefinition");
749 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
750 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
751 artifacts.put("artifacts", artifactDefinition);
752 List<GroupDefinition> groups = new ArrayList<>();
753 GroupDefinition groupDefinition = new GroupDefinition();
754 groupDefinition.setUniqueId("groupDefinitionUniqueId");
755 groupDefinition.setName("groupDefinition");
756 groups.add(groupDefinition);
757 service.setDeploymentArtifacts(deploymentArtifacts);
758 service.setArtifacts(artifacts);
759 service.setGroups(groups);
760 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
762 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
763 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
764 assertNotNull(result.left().value());
768 void testOrganizeVfCsarArtifactsByServiceArtifactOperation() {
769 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
770 artifactPathAndNameList.add(getNonMetaArtifactInfo());
771 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
772 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
773 artifactDefinition.setArtifactName("artifactName");
774 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
775 artifactDefinition.setArtifactChecksum("artifactChecksum");
776 existingArtifactsToHandle.add(artifactDefinition);
777 Service service = createServiceObject(true);
779 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
780 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
781 existingArtifactsToHandle, service, user);
782 assertNotNull(enumMapResponseFormatEither.left().value());
786 void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse() {
787 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
788 artifactPathAndNameList.add(getNonMetaArtifactInfo());
789 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
790 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
791 artifactDefinition.setArtifactName("artifactName");
792 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
793 artifactDefinition.setArtifactChecksum("artifactChecksum");
794 existingArtifactsToHandle.add(artifactDefinition);
795 Service service = createServiceObject(true);
796 Assertions.assertNotNull(
797 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user));
802 void testProcessServiceCsarArtifacts() {
803 CsarInfo csarInfo = getCsarInfo();
804 Service service = createServiceObject(true);
805 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
806 Either<Service, ResponseFormat> resStatus = Either.left(service);
807 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
808 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
809 List<CsarUtils.NonMetaArtifactInfo> objects = new ArrayList<>();
810 objects.add(getNonMetaArtifactInfo());
811 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, objects);
812 Assertions.assertNotNull(
813 sIBL.processCsarArtifacts(csarInfo, service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
817 void testGetValidArtifactNames() {
818 CsarInfo csarInfo = getCsarInfo();
819 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
820 Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIBL.getValidArtifactNames(csarInfo,
821 collectedWarningMessages);
822 assertNotNull(result.left().value());
826 void testCreateOrUpdateSingleNonMetaServiceArtifact() {
827 Service service = createServiceObject(true);
828 CsarInfo csarInfo = getCsarInfo();
829 Map<String, byte[]> csar = csarInfo.getCsar();
830 String rootPath = System.getProperty("user.dir");
832 byte[] data = new byte[0];
833 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
835 data = Files.readAllBytes(path);
836 } catch (IOException e) {
839 csar.put("valid_vf.csar", data);
840 csarInfo.setCsar(csar);
841 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
842 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
843 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
844 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
845 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
846 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
847 artifactDefinition.setArtifactName("artifactName");
848 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
849 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Service.class), any(User.class),
850 anyMap(), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
851 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
852 .thenReturn(Either.left(artifactDefinition));
853 Assertions.assertNotNull(
854 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
855 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
856 artifactDescription, artifactId, artifactOperation, createdArtifacts,
861 void testCreateOrUpdateSingleNonMetaServiceArtifactNull() {
862 Service service = createServiceObject(true);
863 CsarInfo csarInfo = getCsarInfo();
864 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
865 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
866 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
867 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
868 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
869 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
870 .thenReturn(Either.left(artifactDefinition));
871 Assertions.assertNotNull(
872 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
873 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
874 artifactDescription, artifactId, artifactOperation, createdArtifacts,
879 void testCreateGroupsOnResource() {
880 Service service = createServiceObject(true);
881 Map<String, GroupDefinition> groups = new HashMap<>();
882 Assertions.assertNotNull(sIBL.createGroupsOnResource(service, groups));
886 void testCreateGroupsOnResourceNull() {
887 Service service = createServiceObject(true);
888 Map<String, GroupDefinition> groups = new HashMap<>();
889 Assertions.assertNotNull(
890 sIBL.createGroupsOnResource(service, groups));
894 void testUpdateGroupsMembersUsingResource() {
895 Service service = createServiceObject(true);
896 Map<String, GroupDefinition> groups = getGroups();
898 Assertions.assertNotNull(
899 sIBL.updateGroupsMembersUsingResource(groups, service));
903 void testUpdateGroupsMembersUsingResource_left() {
904 Service service = createServiceObject(true);
905 Map<String, GroupDefinition> groups = getGroups();
907 Assertions.assertNotNull(
908 sIBL.updateGroupsMembersUsingResource(groups, service));
912 void testCreateRIAndRelationsFromResourceYaml() throws IOException {
913 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
914 String yamlName = "group.yml";
915 Resource resource = createParseResourceObject(true);
916 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
917 String topologyTemplateYaml = getMainTemplateContent();
918 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
920 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
921 Map<String, Object> map = new HashMap<>();
922 map.put("tosca_definitions_version", "123");
923 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
925 CsarInfo csarInfo = getCsarInfo();
926 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
928 Assertions.assertThrows(ComponentException.class, () -> sIBL
929 .createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
930 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
931 csarInfo, nodeTypesArtifactsToCreate, nodeName));
935 void testCreateResourceInstancesRelations() {
936 String yamlName = "group.yml";
937 Resource resource = createParseResourceObject(true);
938 resource.setComponentInstances(creatComponentInstances());
939 resource.setResourceType(ResourceTypeEnum.VF);
940 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
941 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
942 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
943 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
944 Assertions.assertThrows(ComponentException.class, () -> sIBL
945 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
949 void testCreateResourceInstancesRelations_Empty() {
950 String yamlName = "group.yml";
951 Resource resource = createParseResourceObject(true);
952 resource.setComponentInstances(creatComponentInstances());
953 resource.setResourceType(ResourceTypeEnum.VF);
954 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
955 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
956 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
957 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
958 Assertions.assertThrows(ComponentException.class, () -> sIBL
959 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
963 void testProcessComponentInstance1() {
964 String yamlName = "group.yml";
965 Resource resource = createParseResourceObject(true);
966 Resource originResource = createParseResourceObject(false);
967 originResource.setResourceType(ResourceTypeEnum.VF);
968 List<ComponentInstance> componentInstancesList = creatComponentInstances();
969 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
970 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
971 dataTypeDefinition.setName("dataTypeDefinitionName");
972 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
973 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
974 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
975 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
976 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
977 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
978 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
979 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
980 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
981 Map<String, Resource> originCompMap = new HashMap<>();
982 originCompMap.put("componentUid", originResource);
983 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
984 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
985 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
986 Assertions.assertNotNull(resource);
987 Assertions.assertNotNull(yamlName);
988 sIBL.processComponentInstance(yamlName, resource, componentInstancesList, allDataTypes.left().value(), instProperties,
989 instCapabilties, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes,
990 originCompMap, instInputs, instNodeFilter, null, uploadComponentInstanceInfo);
994 void testProcessComponentInstance_null() {
995 String yamlName = "group.yml";
996 Resource resource = createParseResourceObject(true);
997 Resource originResource = createParseResourceObject(false);
998 List<ComponentInstance> componentInstancesList = creatComponentInstances();
999 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1000 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1001 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1002 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1003 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1004 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1005 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1006 Map<String, Resource> originCompMap = new HashMap<>();
1007 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1008 originCompMap.put("componentUid", originResource);
1009 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1010 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1011 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1013 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1014 resource, componentInstancesList, null, instProperties, instCapabilties,
1015 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1016 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1020 void testAddInputsValuesToRi() {
1021 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1022 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1023 List<UploadPropInfo> uploadPropInfoList = getPropertyList();
1024 properties.put("propertiesMap", uploadPropInfoList);
1025 uploadComponentInstanceInfo.setProperties(properties);
1026 Resource resource = createParseResourceObject(true);
1027 Resource originResource = createParseResourceObject(false);
1028 List<InputDefinition> inputs = new ArrayList<>();
1029 InputDefinition inputDefinition = new InputDefinition();
1030 inputDefinition.setName("inputDefinitionName");
1031 inputDefinition.setUniqueId("uniqueId");
1032 inputDefinition.setType("inputDefinitionType");
1033 inputs.add(inputDefinition);
1034 originResource.setInputs(inputs);
1035 ComponentInstance currentCompInstance = new ComponentInstance();
1036 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1037 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1038 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1039 dataTypeDefinition.setName("dataTypeDefinitionName");
1040 allDataTypes.put("dataTypeDefinitionMap", dataTypeDefinition);
1042 Assertions.assertThrows(ComponentException.class, () -> sIBL
1043 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1044 currentCompInstance, instInputs, allDataTypes));
1048 void testProcessProperty() {
1049 Resource resource = createParseResourceObject(true);
1050 List<InputDefinition> inputs = new ArrayList<>();
1051 InputDefinition inputDefinition = new InputDefinition();
1052 inputDefinition.setName("inputDefinitionName");
1053 inputDefinition.setUniqueId("uniqueId");
1054 inputDefinition.setType("inputDefinitionType");
1055 inputs.add(inputDefinition);
1056 resource.setInputs(inputs);
1057 ComponentInstance currentCompInstance = null;
1058 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1059 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1060 currPropertiesMap.put("propertyInfoName", inputDefinition);
1061 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1062 List<UploadPropInfo> propertyList = getPropertyList();
1063 Assertions.assertNotNull(resource);
1064 Assertions.assertNotNull(currPropertiesMap);
1065 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1069 void testHandleSubstitutionMappings() {
1070 Resource resource = createParseResourceObject(true);
1071 resource.setResourceType(ResourceTypeEnum.VF);
1072 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1073 when(toscaOperationFacade.getToscaFullElement(anyString()))
1074 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1076 Assertions.assertThrows(ComponentException.class,
1077 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1081 void testHandleSubstitutionMappings_left() {
1082 Resource resource = createParseResourceObject(true);
1083 resource.setResourceType(ResourceTypeEnum.VF);
1084 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1085 when(toscaOperationFacade.getToscaFullElement(anyString()))
1086 .thenReturn(Either.left(resource));
1088 Assertions.assertThrows(ComponentException.class,
1089 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1093 void testCreateResourceInstances() {
1094 String yamlName = "group.yml";
1095 Resource resource = createParseResourceObject(true);
1096 Resource originResource = createParseResourceObject(false);
1097 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1098 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
1099 nodesInfoValue.setName("zxjTestImportServiceAb");
1100 nodesInfoValue.setRequirements(gerRequirements());
1101 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1102 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1103 nodeNamespaceMap.put("resources", originResource);
1105 Assertions.assertThrows(ComponentException.class,
1106 () -> sIBL.createResourceInstances(yamlName, resource, uploadResInstancesMap, nodeNamespaceMap));
1110 void testHandleNodeTypes() throws IOException {
1111 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1112 String yamlName = "group.yml";
1113 Resource resource = createParseResourceObject(true);
1114 String topologyTemplateYaml = getMainTemplateContent();
1115 boolean needLock = true;
1116 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1117 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1118 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1119 Map<String, Object> map = new HashMap<>();
1120 map.put("tosca_definitions_version", "123");
1121 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1122 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1123 CsarInfo csarInfo = getCsarInfo();
1124 Assertions.assertNotNull(resource);
1126 sIBL.handleNodeTypes(yamlName, resource, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1127 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
1131 void testHandleNestedVfc1() {
1132 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1133 Resource resource = createParseResourceObject(false);
1134 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1135 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1136 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1137 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1138 nodeTypeInfo.setTemplateFileName("groups.yml");
1139 nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
1140 nodesInfo.put(nodeName, nodeTypeInfo);
1141 CsarInfo csarInfo = getCsarInfo();
1143 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(resource,
1144 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1148 void testHandleComplexVfc1() {
1149 Resource resource = createParseResourceObject(true);
1150 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1151 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1152 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1153 CsarInfo csarInfo = getCsarInfo();
1154 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1155 String yamlName = "group.yml";
1156 when(serviceImportParseLogic.buildValidComplexVfc(any(Resource.class), any(CsarInfo.class), anyString(),
1157 anyMap())).thenReturn(createParseResourceObject(false));
1158 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1159 .thenReturn(Either.left(resource));
1160 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class),
1161 anyBoolean())).thenReturn(Either.left(true));
1163 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleComplexVfc(resource,
1164 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName));
1168 void testCreateNodeTypes1() {
1169 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1170 String yamlName = "group.yml";
1171 Resource resource = createParseResourceObject(false);
1172 boolean needLock = true;
1173 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1174 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
1175 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1176 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
1177 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1178 artifactDefinition.setArtifactName("artifactName");
1179 artifactDefinitions.add(artifactDefinition);
1180 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
1181 artifactDefinitions);
1182 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
1183 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1184 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1185 Map<String, Object> map = new HashMap<>();
1186 map.put("tosca_definitions_version", "123");
1187 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1188 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1190 CsarInfo csarInfo = getCsarInfo();
1191 Map<String, Object> mapToConvert = new HashMap<>();
1192 Map<String, Object> nodeTypes = new HashMap<>();
1193 nodeTypes.put(nodeName, "");
1194 Assertions.assertNotNull(resource);
1196 sIBL.createNodeTypes(yamlName,
1197 resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1198 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
1202 void testCreateNodeTypeResourceFromYaml() throws IOException {
1203 String yamlName = "group.yml";
1204 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1205 Map<String, Object> nodeMap = new HashMap<>();
1206 nodeMap.put(nodeName, getGroupsYaml());
1207 Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
1208 Map<String, Object> mapToConvert = new HashedMap();
1209 Resource resourceVf = createParseResourceObject(false);
1210 boolean needLock = true;
1211 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
1212 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1213 boolean forceCertificationAllowed = true;
1214 CsarInfo csarInfo = getCsarInfo();
1215 boolean isNested = true;
1216 UploadResourceInfo resourceMetaData = new UploadResourceInfo();
1217 resourceMetaData.setResourceType("VFC");
1218 ImmutablePair<Resource, ActionStatus> immutablePair = new ImmutablePair<>(resourceVf, ActionStatus.CREATED);
1219 when(serviceImportParseLogic.fillResourceMetadata(anyString(), any(Resource.class), anyString(), any(User.class)))
1220 .thenReturn(resourceMetaData);
1221 when(serviceImportParseLogic.buildNodeTypeYaml(any(Map.Entry.class), anyMap(), anyString(), any(CsarInfo.class)))
1222 .thenReturn(nodeName);
1223 when(serviceBusinessLogic.validateUser(any(User.class), anyString(), any(Component.class), any(AuditingActionEnum.class),
1224 anyBoolean())).thenReturn(user);
1225 when(serviceImportParseLogic.createResourceFromNodeType(anyString(), any(UploadResourceInfo.class), any(User.class), anyBoolean(),
1227 anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
1228 anyString(), anyBoolean())).thenReturn(immutablePair);
1229 Assertions.assertNotNull(
1230 sIBL.createNodeTypeResourceFromYaml(yamlName, nodeNameValue, user, mapToConvert,
1231 resourceVf, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1232 forceCertificationAllowed, csarInfo, isNested));
1236 void testCreateRIAndRelationsFromYaml() {
1237 String yamlName = "group.yml";
1238 Service service = createServiceObject(true);
1239 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
1240 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1242 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1243 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1244 CsarInfo csarInfo = getCsarInfo();
1245 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1246 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1248 Assertions.assertNotNull(sIBL
1249 .createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap,
1250 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1251 csarInfo, nodeTypesArtifactsToCreate, nodeName));
1255 void testCreateServiceInstancesRelations() {
1256 String yamlName = "group.yml";
1257 Service service = createServiceObject(true);
1258 service.setComponentInstances(creatComponentInstances());
1259 Resource newResource = createNewResource();
1260 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1261 ComponentParametersView componentParametersView = new ComponentParametersView();
1262 RequirementDefinition requirementDefinition = new RequirementDefinition();
1263 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1264 capabilityDefinition.setName("as");
1265 capabilityDefinition.setUniqueId("1");
1266 capabilityDefinition.setOwnerId("2");
1267 ResponseFormat responseFormat = new ResponseFormat();
1268 responseFormat.setStatus(200);
1269 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(newResource);
1270 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1271 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(service));
1272 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1273 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1274 anyString())).thenReturn(Either.left(requirementDefinition));
1275 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1276 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1277 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1278 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
1279 Assertions.assertNotNull(sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
1283 void testCreateServiceInstancesRelations_Empty() {
1284 String yamlName = "group.yml";
1285 Service service = createServiceObject(true);
1286 service.setComponentInstances(creatComponentInstances());
1287 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1289 Assertions.assertThrows(ComponentException.class,
1290 () -> sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
1294 void testProcessComponentInstance() {
1295 String yamlName = "group.yml";
1296 Service service = createServiceObject(true);
1297 Resource originResource = createParseResourceObject(false);
1298 originResource.setResourceType(ResourceTypeEnum.VF);
1299 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1300 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
1301 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1302 dataTypeDefinition.setName("dataTypeDefinitionName");
1303 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
1304 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
1305 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1306 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1307 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1308 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1309 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1310 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1311 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1312 Map<String, Resource> originCompMap = new HashMap<>();
1313 originCompMap.put("componentUid", originResource);
1314 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1315 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1316 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
1317 Assertions.assertNotNull(service);
1319 sIBL.processComponentInstance(yamlName, service, componentInstancesList, allDataTypes.left().value(),
1320 instProperties, instCapabilties, instRequirements, instDeploymentArtifacts,
1321 instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, null,
1322 uploadComponentInstanceInfo);
1326 void testProcessComponentInstance_null2() {
1327 String yamlName = "group.yml";
1328 Service service = createServiceObject(true);
1329 Resource originResource = createParseResourceObject(false);
1330 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1331 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1332 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1333 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1334 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1335 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1336 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1337 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1338 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1339 Map<String, Resource> originCompMap = new HashMap<>();
1340 originCompMap.put("componentUid", originResource);
1341 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1342 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1343 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1345 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1346 service, componentInstancesList, null, instProperties, instCapabilties,
1347 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1348 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1352 void testAddInputsValuesToRi2() {
1353 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1354 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1355 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
1356 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1357 uploadPropInfo.setName("uploadPropInfo");
1358 uploadPropInfoList.add(uploadPropInfo);
1359 uploadPropInfoList.add(uploadPropInfo);
1360 properties.put("propertiesMap", uploadPropInfoList);
1361 uploadComponentInstanceInfo.setProperties(properties);
1362 Service resource = createServiceObject(true);
1363 Resource originResource = createParseResourceObject(false);
1364 List<InputDefinition> inputs = new ArrayList<>();
1365 InputDefinition inputDefinition = new InputDefinition();
1366 inputDefinition.setUniqueId("uniqueId");
1367 inputs.add(inputDefinition);
1368 originResource.setInputs(inputs);
1369 ComponentInstance currentCompInstance = new ComponentInstance();
1370 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1371 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1373 Assertions.assertThrows(ComponentException.class, () -> sIBL
1374 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1375 currentCompInstance, instInputs, allDataTypes));
1379 void testProcessProperty2() {
1380 Service resource = createServiceObject(true);
1381 List<InputDefinition> inputs = new ArrayList<>();
1382 ComponentInstance currentCompInstance = null;
1383 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1384 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1385 InputDefinition inputDefinition = new InputDefinition();
1386 inputDefinition.setName("inputDefinitionName");
1387 inputDefinition.setType("inputDefinitionType");
1388 inputs.add(inputDefinition);
1389 currPropertiesMap.put("propertyInfoName", inputDefinition);
1390 resource.setInputs(inputs);
1391 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1392 List<UploadPropInfo> propertyList = new ArrayList<>();
1393 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1394 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1395 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1396 getInputValueDataDefinition.setInputName("inputDefinitionName");
1397 get_input.add(getInputValueDataDefinition);
1398 UploadPropInfo propertyInfo = new UploadPropInfo();
1399 propertyInfo.setValue("value");
1400 propertyInfo.setGet_input(get_input);
1401 propertyInfo.setName("propertyInfoName");
1402 propertyList.add(propertyInfo);
1403 Assertions.assertNotNull(resource);
1405 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1409 void testProcessGetInput() {
1410 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1411 List<InputDefinition> inputs = new ArrayList<>();
1412 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1414 Assertions.assertThrows(ComponentException.class, () -> sIBL.processGetInput(getInputValues, inputs, getInputIndex));
1418 void testProcessGetInput_optional() {
1419 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1420 List<InputDefinition> inputs = new ArrayList<>();
1421 InputDefinition inputDefinition = new InputDefinition();
1422 inputDefinition.setUniqueId("uniqueId");
1423 inputDefinition.setName("InputName");
1424 inputs.add(inputDefinition);
1425 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1426 getInputIndex.setInputName("InputName");
1427 Assertions.assertNotNull(inputs);
1429 sIBL.processGetInput(getInputValues, inputs, getInputIndex);
1433 void testAddPropertyValuesToRi() {
1434 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1435 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1436 Resource resource = createParseResourceObject(true);
1437 List<InputDefinition> inputs = new ArrayList<>();
1438 InputDefinition inputDefinition = new InputDefinition();
1439 inputDefinition.setName("inputDefinitionName");
1440 inputDefinition.setUniqueId("uniqueId");
1441 inputDefinition.setType("inputDefinitionType");
1442 inputs.add(inputDefinition);
1443 resource.setInputs(inputs);
1444 Resource originResource = createParseResourceObject(false);
1445 originResource.setProperties(getProperties());
1446 ComponentInstance currentCompInstance = new ComponentInstance();
1447 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1448 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1449 ResponseFormat responseFormat = new ResponseFormat();
1450 when(serviceImportParseLogic.findInputByName(eq(inputs), any(GetInputValueDataDefinition.class)))
1451 .thenReturn(inputDefinition);
1452 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1453 Assertions.assertNotNull(
1454 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1455 currentCompInstance, instProperties, allDataTypes));
1459 void testAddPropertyValuesToRi_else() {
1460 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1461 Resource resource = createParseResourceObject(true);
1462 Resource originResource = createParseResourceObject(false);
1463 originResource.setProperties(getProperties());
1464 ComponentInstance currentCompInstance = new ComponentInstance();
1465 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1466 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1467 ResponseFormat responseFormat = new ResponseFormat();
1468 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1469 Assertions.assertNotNull(
1470 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
1471 instProperties, allDataTypes));
1475 void testAddPropertyValuesToRi2() {
1476 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1477 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1478 Service service = createServiceObject(true);
1479 List<InputDefinition> inputs = new ArrayList<>();
1480 InputDefinition inputDefinition = new InputDefinition();
1481 inputDefinition.setName("inputDefinitionName");
1482 inputDefinition.setUniqueId("uniqueId");
1483 inputDefinition.setType("inputDefinitionType");
1484 inputs.add(inputDefinition);
1485 service.setInputs(inputs);
1486 Resource originResource = createParseResourceObject(false);
1487 originResource.setProperties(getProperties());
1488 ComponentInstance currentCompInstance = new ComponentInstance();
1489 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1490 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1491 ResponseFormat responseFormat = new ResponseFormat();
1492 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1493 when(serviceImportParseLogic.findInputByName(anyList(), any(GetInputValueDataDefinition.class)))
1494 .thenReturn(inputDefinition);
1495 Assertions.assertNotNull(
1496 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource,
1497 currentCompInstance, instProperties, allDataTypes));
1501 void testAddPropertyValuesToRi2_else() {
1502 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1503 Service service = createServiceObject(true);
1504 Resource originResource = createParseResourceObject(false);
1505 originResource.setProperties(getProperties());
1506 ComponentInstance currentCompInstance = new ComponentInstance();
1507 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1508 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1509 ResponseFormat responseFormat = new ResponseFormat();
1510 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1511 Assertions.assertNotNull(
1512 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1513 instProperties, allDataTypes));
1517 void testProcessComponentInstanceCapabilities() {
1518 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1519 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1520 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1521 uploadComponentInstanceInfo.setCapabilities(getCapabilities());
1522 ComponentInstance currentCompInstance = new ComponentInstance();
1523 Resource originResource = createParseResourceObject(false);
1524 Assertions.assertNotNull(originResource);
1525 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1530 void testProcessComponentInstanceCapabilities_null() {
1531 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1532 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1533 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1534 ComponentInstance currentCompInstance = new ComponentInstance();
1535 Resource originResource = createParseResourceObject(false);
1536 Assertions.assertNotNull(originResource);
1538 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1543 void testUpdateCapabilityPropertiesValues() {
1544 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1545 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1546 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1547 Assertions.assertNull(allDataTypes);
1548 sIBL.updateCapabilityPropertiesValues(null, originCapabilities, newPropertiesMap);
1552 void testUpdatePropertyValues() {
1553 List<ComponentInstanceProperty> properties = new ArrayList<>();
1554 Map<String, UploadPropInfo> newProperties = new HashMap<>();
1555 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1556 Assertions.assertNotNull(allDataTypes);
1557 sIBL.updatePropertyValues(properties, newProperties, allDataTypes);
1561 void testUpdatePropertyValue() {
1562 ComponentInstanceProperty property = new ComponentInstanceProperty();
1563 property.setType("services");
1564 UploadPropInfo propertyInfo = new UploadPropInfo();
1565 propertyInfo.setValue("value");
1566 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1567 when(serviceBusinessLogic.validatePropValueBeforeCreate(any(IPropertyInputCommon.class), anyString(), anyBoolean(), anyMap())).thenReturn(
1569 Assertions.assertNotNull(sIBL.updatePropertyValue(property, propertyInfo, allDataTypes));
1573 void testGetOriginResource() {
1574 String yamlName = "group.yml";
1575 Map<String, Resource> originCompMap = new HashMap<>();
1576 ComponentInstance currentCompInstance = new ComponentInstance();
1577 currentCompInstance.setComponentUid("currentCompInstance");
1578 when(toscaOperationFacade.getToscaFullElement(anyString()))
1579 .thenReturn(Either.left(createParseResourceObject(true)));
1580 Assertions.assertNotNull(sIBL.getOriginResource(yamlName, originCompMap, currentCompInstance));
1584 void testUpdateCalculatedCapReqWithSubstitutionMappings() {
1585 Resource resource = createParseResourceObject(false);
1586 resource.setComponentInstances(creatComponentInstances());
1587 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1589 when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
1590 Assertions.assertNotNull(sIBL.updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap));
1594 void testFillUpdatedInstCapabilitiesRequirements() {
1595 List<ComponentInstance> componentInstances = creatComponentInstances();
1596 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1597 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1598 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
1599 Assertions.assertNotNull(componentInstances);
1601 sIBL.fillUpdatedInstCapabilitiesRequirements(componentInstances, uploadResInstancesMap,
1602 updatedInstCapabilities, updatedInstRequirement);
1606 void testFillUpdatedInstCapabilities() {
1607 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
1608 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1609 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1610 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1611 capabilityDefinition.setName("mme_ipu_vdu.feature");
1612 capabilityDefinitionList.add(capabilityDefinition);
1613 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
1614 ComponentInstance instance = new ComponentInstance();
1615 instance.setCapabilities(capabilities);
1616 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1617 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
1618 Assertions.assertNotNull(instance);
1620 sIBL.fillUpdatedInstCapabilities(updatedInstCapabilties, instance, capabilitiesNamesToUpdate);
1624 void testFillUpdatedInstRequirements() {
1625 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
1627 ComponentInstance instance = new ComponentInstance();
1628 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1629 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1630 RequirementDefinition requirementDefinition = new RequirementDefinition();
1631 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1632 requirementDefinitionList.add(requirementDefinition);
1633 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
1634 instance.setRequirements(requirements);
1635 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1636 requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
1637 "requirementsNamesToUpdate");
1638 Assertions.assertNotNull(instance);
1640 sIBL.fillUpdatedInstRequirements(updatedInstRequirements, instance, requirementsNamesToUpdate);
1644 void testAddRelationsToRI() {
1645 String yamlName = "group.yml";
1646 Service service = createServiceObject(true);
1648 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1649 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1650 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1651 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1652 ComponentInstance componentInstance = new ComponentInstance();
1653 componentInstance.setName("zxjTestImportServiceAb");
1654 componentInstancesList.add(componentInstance);
1655 service.setComponentInstances(componentInstancesList);
1656 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1657 RequirementDefinition requirementDefinition = new RequirementDefinition();
1658 requirementDefinition.setOwnerId("1");
1659 requirementDefinition.setUniqueId("2");
1660 requirementDefinition.setCapability("3");
1661 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1662 capabilityDefinition.setName("4");
1663 capabilityDefinition.setUniqueId("5");
1664 capabilityDefinition.setOwnerId("6");
1665 ResponseFormat responseFormat = new ResponseFormat();
1666 responseFormat.setStatus(200);
1667 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1668 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1669 anyString())).thenReturn(Either.left(requirementDefinition));
1670 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1671 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1672 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1673 Assertions.assertNotNull(service);
1675 sIBL.addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1679 void testAddRelationsToRI_null() {
1680 String yamlName = "group.yml";
1681 Service service = createServiceObject(true);
1682 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1683 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1684 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1685 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1686 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1688 Assertions.assertThrows(ComponentException.class, () -> sIBL.addRelationsToRI(yamlName,
1689 service, uploadResInstancesMap, componentInstancesList, relations));
1693 void testAddRelationToRI() {
1694 String yamlName = "group.yml";
1695 Service service = createServiceObject(true);
1696 service.setComponentInstances(creatComponentInstances());
1698 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1699 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1700 RequirementDefinition requirementDefinition = new RequirementDefinition();
1701 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1702 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1703 capabilityDefinition.setName("capabilityDefinitionName");
1704 capabilityDefinition.setUniqueId("capabilityDefinitionUniqueId");
1705 capabilityDefinition.setOwnerId("capabilityDefinitionOwnerId");
1706 ResponseFormat responseFormat = new ResponseFormat();
1707 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
1708 any(ComponentInstance.class), anyString())).thenReturn(Either.left(requirementDefinition));
1709 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1710 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1711 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1712 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1713 Assertions.assertNotNull(relations.get(0).getRelationships().get(0).getOperations());
1717 void testAddRelationToRI_null() {
1718 String yamlName = "group.yml";
1719 Service service = createServiceObject(true);
1720 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1721 service.setComponentInstances(componentInstancesList);
1722 ResponseFormat responseFormat = new ResponseFormat();
1723 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1724 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1725 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1726 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1730 void testGetResourceAfterCreateRelations() {
1731 Service service = createServiceObject(true);
1732 ComponentParametersView componentParametersView = createComponentParametersView();
1733 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1734 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1735 .thenReturn(Either.left(createServiceObject(true)));
1736 Assertions.assertNotNull(sIBL.getResourceAfterCreateRelations(service));
1740 void testCreateServiceInstances() {
1741 String yamlName = "group.yml";
1742 Service service = createServiceObject(true);
1743 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1744 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1745 uploadResInstancesMap.put("uploadResInstancesMap", nodesInfoValue);
1746 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1747 Resource resource = createParseResourceObject(true);
1748 resource.setToscaResourceName("toscaResourceName");
1749 nodeNamespaceMap.put("nodeNamespaceMap", resource);
1751 Assertions.assertThrows(ComponentException.class,
1752 () -> sIBL.createServiceInstances(yamlName, service, uploadResInstancesMap, nodeNamespaceMap));
1756 void testCreateAndAddResourceInstance() {
1757 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1758 String yamlName = "group.yml";
1759 Resource resource = createParseResourceObject(false);
1760 Resource originResource = createParseResourceObject(true);
1761 originResource.setResourceType(ResourceTypeEnum.VF);
1762 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1763 nodeNamespaceMap.put("resources", originResource);
1764 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1765 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1767 Assertions.assertThrows(ComponentException.class, () -> sIBL
1768 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, resource,
1769 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1773 void testCreateAndAddResourceInstances() {
1774 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1775 String yamlName = "group.yml";
1776 Service service = createServiceObject(true);
1777 service.setServiceType("services");
1778 Resource originResource = createParseResourceObject(true);
1779 originResource.setResourceType(ResourceTypeEnum.VF);
1780 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1781 nodeNamespaceMap.put("resources", originResource);
1782 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1783 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1785 Assertions.assertThrows(ComponentException.class, () -> sIBL
1786 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service,
1787 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1791 void testValidateResourceInstanceBeforeCreate() {
1792 String yamlName = "group.yml";
1793 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1794 Resource originResource = createParseResourceObject(true);
1795 ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
1796 componentMetadataDataDefinition.setState(LifecycleStateEnum.CERTIFIED.name());
1797 ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
1798 originResource.setComponentMetadataDefinition(componentMetadataDefinition);
1799 originResource.setComponentType(ComponentTypeEnum.RESOURCE);
1800 originResource.setToscaResourceName("toscaResourceName");
1801 originResource.setResourceType(ResourceTypeEnum.VF);
1802 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1803 nodeNamespaceMap.put("resources", originResource);
1804 when(toscaOperationFacade.getLatestByToscaResourceName(RESOURCE_TOSCA_NAME, null)).thenReturn(Either.left(originResource));
1805 Assertions.assertNotNull(
1806 sIBL.validateResourceInstanceBeforeCreate(yamlName, null, uploadComponentInstanceInfo, nodeNamespaceMap));
1810 void testHandleServiceNodeTypes() {
1811 String yamlName = "group.yml";
1812 Service service = createServiceObject(true);
1813 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1815 boolean needLock = true;
1816 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1817 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1818 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1819 CsarInfo csarInfo = getCsarInfo();
1820 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1821 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
1822 Assertions.assertNotNull(service);
1824 sIBL.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1825 nodeTypesNewCreatedArtifacts,
1826 nodeTypesInfo, csarInfo, nodeName);
1830 void testValidateResourceNotExisted() {
1831 String type = "org.openecomp.resource.vf";
1833 Assertions.assertThrows(ComponentException.class, () -> sIBL.validateResourceNotExisted(type));
1837 void testHandleNestedVF() {
1838 Service service = createServiceObject(true);
1839 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1840 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1841 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1842 CsarInfo csarInfo = getCsarInfo();
1843 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1845 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVF(service,
1846 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1850 void testHandleNestedVfc() {
1851 Service service = createServiceObject(true);
1852 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1853 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1854 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1855 CsarInfo csarInfo = getCsarInfo();
1856 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1858 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(service,
1859 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1863 void testHandleComplexVfc() {
1864 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1865 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1866 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1867 CsarInfo csarInfo = getCsarInfo();
1868 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1869 String yamlName = "group.yml";
1870 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1871 .thenReturn(createNewResource());
1872 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1873 .thenReturn(Either.left(createNewResource()));
1874 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class), anyBoolean()))
1875 .thenReturn(Either.left(true));
1877 Assertions.assertThrows(ComponentException.class, () -> sIBL
1878 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1879 csarInfo, nodeName, yamlName));
1883 void testHandleComplexVfcStatus() {
1884 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1885 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1886 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1887 CsarInfo csarInfo = getCsarInfo();
1888 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1889 String yamlName = "group.yml";
1890 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1891 .thenReturn(createNewResource());
1892 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1893 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1895 Assertions.assertThrows(ComponentException.class, () -> sIBL
1896 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1897 csarInfo, nodeName, yamlName));
1901 void testHandleComplexVfc2() {
1902 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1903 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1904 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1905 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1906 String yamlName = "group.yml";
1907 CsarInfo csarInfo = getCsarInfo();
1908 Map<String, byte[]> csar = new HashMap<>();
1909 csar.put(yamlName, yamlName.getBytes());
1910 csarInfo.setCsar(csar);
1911 Resource oldComplexVfc = createParseResourceObject(false);
1912 Resource newComplexVfc = createParseResourceObject(true);
1914 Assertions.assertThrows(ComponentException.class, () -> sIBL
1915 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1916 csarInfo, nodeName, yamlName, oldComplexVfc, newComplexVfc));
1920 void testUpdateResourceFromYaml() throws IOException {
1921 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1922 Resource newResource = createNewResource();
1923 Resource oldResource = createOldResource();
1924 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1925 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1926 String yamlFileName = "group.yml";
1927 String yamlFileContent = getYamlFileContent();
1928 CsarInfo csarInfo = getCsarInfo();
1929 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1930 Map<String, Object> map = new HashMap<>();
1931 map.put("tosca_definitions_version", "123");
1932 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1933 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1934 boolean isNested = true;
1936 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1937 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1938 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
1939 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
1940 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
1941 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
1942 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
1943 .thenReturn(Either.left(newResource));
1944 Assertions.assertThrows(ComponentException.class, () -> sIBL
1945 .updateResourceFromYaml(oldResource, newResource, actionEnum, createdArtifacts,
1946 yamlFileName, yamlFileContent, csarInfo, nodeTypesInfo,
1947 nodeTypesArtifactsToHandle, nodeName, isNested));
1951 void testCreateResourceFromYaml() throws IOException {
1952 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1953 Resource resource = createParseResourceObject(true);
1954 String topologyTemplateYaml = getMainTemplateContent();
1955 String yamlName = "group.yml";
1957 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1958 Map<String, Object> map = new HashMap<>();
1959 map.put("tosca_definitions_version", "123");
1960 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1962 CsarInfo csarInfo = getCsarInfo();
1963 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1964 boolean shouldLock = false;
1965 boolean inTransaction = true;
1967 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1968 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1969 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Component.class))).thenReturn(resource);
1970 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
1971 .thenReturn(Either.left(false));
1972 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
1973 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceFromYaml(resource,
1974 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
1975 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
1979 void testCreateResourceAndRIsFromYaml() throws IOException {
1980 String yamlName = "group.yml";
1981 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1982 Resource resource = createParseResourceObject(true);
1983 resource.setSystemName("SystemName");
1984 resource.setComponentType(ComponentTypeEnum.RESOURCE);
1985 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1986 boolean isNormative = true;
1987 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1988 String topologyTemplateYaml = getMainTemplateContent();
1989 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1990 Map<String, Object> map = new HashMap<>();
1991 map.put("tosca_definitions_version", "123");
1992 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1993 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1995 CsarInfo csarInfo = getCsarInfo();
1996 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1997 boolean shouldLock = false;
1998 boolean inTransaction = true;
1999 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Resource.class)))
2000 .thenReturn(resource);
2002 when(serviceBusinessLogic.lockComponentByName(anyString(), any(), anyString()))
2003 .thenReturn(Either.left(true));
2005 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2006 .thenReturn(Either.left(false));
2008 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2010 Assertions.assertThrows(ComponentException.class, () -> sIBL
2011 .createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, actionEnum,
2012 isNormative, createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo,
2013 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
2017 void testCreateGroupsOnResource2() {
2018 Resource resource = createParseResourceObject(false);
2019 Map<String, GroupDefinition> groups = null;
2020 List<GroupDefinition> groupDefinitionList = new ArrayList<>();
2021 GroupDefinition groupDefinition = new GroupDefinition();
2022 groupDefinition.setUniqueId("groupDefinitionUniqueId");
2023 groupDefinition.setName("groupDefinition");
2024 groupDefinitionList.add(groupDefinition);
2026 Assertions.assertNotNull(
2027 sIBL.createGroupsOnResource(resource, groups));
2031 void testCreateGroupsOnResource2_null() {
2032 Resource resource = createParseResourceObject(false);
2033 Map<String, GroupDefinition> groups = null;
2035 Either<Resource, ResponseFormat> result = sIBL.createGroupsOnResource(resource, groups);
2036 assertEquals(result.left().value(), resource);
2040 void testUpdateGroupsMembersUsingResource2() {
2041 Resource resource = createParseResourceObject(true);
2042 Map<String, GroupDefinition> groups = getGroups();
2044 Assertions.assertNotNull(
2045 sIBL.updateGroupsMembersUsingResource(groups, resource));
2049 void testUpdateGroupsMembersUsingResource_left2() {
2050 Resource resource = createParseResourceObject(true);
2051 Map<String, GroupDefinition> groups = getGroups();
2053 Assertions.assertNotNull(
2054 sIBL.updateGroupsMembersUsingResource(groups, resource));
2058 void testUpdateGroupMembers() throws IOException {
2059 Map<String, GroupDefinition> groups = new HashMap<>();
2060 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2061 Resource component = createParseResourceObject(true);
2062 List<ComponentInstance> componentInstances = creatComponentInstances();
2063 String groupName = "tosca_simple_yaml_1_1";
2064 Map<String, String> members = new HashMap<>();
2065 members.put("zxjTestImportServiceAb", getGroupsYaml());
2066 Assertions.assertNotNull(component);
2068 sIBL.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2072 void testUpdateGroupMembers_null() throws IOException {
2073 Map<String, GroupDefinition> groups = new HashMap<>();
2074 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2075 Resource component = createParseResourceObject(true);
2076 List<ComponentInstance> componentInstances = new ArrayList<>();
2077 String groupName = "tosca_simple_yaml_1_1";
2078 Map<String, String> members = new HashMap<>();
2079 members.put("zxjTestImportServiceAb", getGroupsYaml());
2081 Assertions.assertThrows(ComponentException.class, () -> sIBL.updateGroupMembers(groups,
2082 updatedGroupDefinition, component, componentInstances, groupName, members));
2086 void setCreateResourceTransaction() {
2087 Resource resource = createParseResourceObject(false);
2088 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2089 boolean isNormative = true;
2090 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2091 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
2093 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2097 void setCreateResourceTransaction_leftTrue() {
2098 Resource resource = createParseResourceObject(false);
2099 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2100 boolean isNormative = true;
2101 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(true));
2103 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2107 void setCreateResourceTransaction_Left() {
2108 Resource resource = createParseResourceObject(false);
2109 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2110 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(false));
2111 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2112 Assertions.assertNotNull(sIBL.createResourceTransaction(resource, user, false));
2116 void testUpdateExistingResourceByImport() {
2117 Resource newResource = createNewResource();
2118 Resource oldResource = createOldResource();
2119 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
2120 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
2121 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
2122 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
2123 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
2124 .thenReturn(Either.left(newResource));
2125 Assertions.assertNotNull(sIBL.updateExistingResourceByImport(newResource, oldResource, user, true, false, true));
2129 void testCreateNewResourceToOldResource() {
2130 Resource newResource = createNewResource();
2131 Resource oldResource = createOldResource();
2133 sIBL.createNewResourceToOldResource(newResource, oldResource, user);
2134 assertEquals(newResource.getSystemName(), oldResource.getSystemName());
2138 void testCreateResourcesFromYamlNodeTypesList() {
2139 String yamlName = "group.yml";
2140 Service service = createServiceObject(true);
2141 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2142 boolean needLock = true;
2143 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2144 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2145 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2146 CsarInfo csarInfo = getCsarInfo();
2148 Assertions.assertThrows(ComponentException.class, () -> sIBL
2149 .createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock,
2150 nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo));
2154 void testCreateNodeTypes() {
2155 String yamlName = "group.yml";
2156 Service service = createServiceObject(true);
2157 boolean needLock = true;
2158 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2159 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2160 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2161 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2162 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2163 artifactDefinition.setArtifactName("artifactName");
2164 artifactDefinitions.add(artifactDefinition);
2165 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2166 artifactDefinitions);
2167 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2168 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2169 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2170 CsarInfo csarInfo = getCsarInfo();
2171 Map<String, Object> mapToConvert = new HashMap<>();
2172 Map<String, Object> nodeTypes = new HashMap<>();
2173 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2174 nodeTypesInfo.put("nodeTyp", nodeTypeInfo);
2175 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2178 Assertions.assertThrows(ComponentException.class, () -> sIBL.createNodeTypes(yamlName,
2179 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2180 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes));
2184 void testCreateNodeTypesElse() {
2185 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2186 String yamlName = "group.yml";
2187 Service service = createServiceObject(true);
2188 boolean needLock = true;
2189 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2190 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2191 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2192 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2193 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2194 artifactDefinition.setArtifactName("artifactName");
2195 artifactDefinitions.add(artifactDefinition);
2196 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2197 artifactDefinitions);
2198 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2199 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2200 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2201 Map<String, Object> map = new HashMap<>();
2202 map.put("tosca_definitions_version", "123");
2203 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
2204 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
2206 CsarInfo csarInfo = getCsarInfo();
2207 Map<String, Object> mapToConvert = new HashMap<>();
2208 Map<String, Object> nodeTypes = new HashMap<>();
2209 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2210 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2212 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class),
2213 anyMap(), any(Service.class), anyBoolean(), anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
2214 anyBoolean())).thenReturn(getResourceCreated());
2215 Assertions.assertNotNull(service);
2217 sIBL.createNodeTypes(yamlName,
2218 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2219 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
2222 protected ImmutablePair<Resource, ActionStatus> getResourceCreated() {
2223 Resource resource = createOldResource();
2224 ImmutablePair<Resource, ActionStatus> resourceCreated = new ImmutablePair<>(resource, ActionStatus.OK);
2226 return resourceCreated;
2229 protected Resource createNewResource() {
2230 Resource newResource = createParseResourceObject(false);
2231 newResource.setVersion("1.0");
2232 newResource.setInvariantUUID("");
2233 newResource.setLifecycleState(null);
2234 newResource.setUUID("");
2235 newResource.setNormalizedName("");
2236 newResource.setSystemName("");
2237 newResource.setCsarUUID("");
2238 newResource.setImportedToscaChecksum("");
2239 newResource.setDerivedFromGenericType("");
2240 newResource.setDerivedFromGenericVersion("");
2241 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2242 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2243 artifactDefinition.setArtifactName("artifactDefinition");
2244 toscaArtifacts.put("toscaArtifactsMap", artifactDefinition);
2245 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2246 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2247 interfaceDefinition.setOwnerId("OwnerId");
2248 interfaces.put("interfacesMap", interfaceDefinition);
2249 newResource.setInterfaces(interfaces);
2250 newResource.setToscaArtifacts(toscaArtifacts);
2251 newResource.setProperties(getProperties());
2255 protected Resource createOldResource() {
2256 Resource newResource = createParseResourceObject(false);
2257 newResource.setVersion("1.0");
2258 newResource.setUniqueId("ResourceUniqueId");
2259 newResource.setInvariantUUID("552e8f6c-340c-4fb4-8a82-fe7732fd8010");
2260 newResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
2261 newResource.setUUID("13065b80-ca96-4331-b643-d28aeaf961cb");
2262 newResource.setNormalizedName("NormalizedName");
2263 newResource.setSystemName("default");
2264 newResource.setCsarUUID("CsarUUID");
2265 newResource.setImportedToscaChecksum("ImportedToscaChecksum");
2266 newResource.setDerivedFromGenericType("DerivedFromGenericType");
2267 newResource.setDerivedFromGenericVersion("0.1");
2268 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2269 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2270 artifactDefinition.setArtifactName("tosca_simple_yaml_1_1");
2271 toscaArtifacts.put("tosca_definitions_version", artifactDefinition);
2272 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2273 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2274 interfaceDefinition.setDescription("Invoked upon receipt of an Instantiate VNF request");
2275 interfaces.put("tosca_simple_yaml_1_1", interfaceDefinition);
2276 newResource.setInterfaces(interfaces);
2277 newResource.setToscaArtifacts(toscaArtifacts);
2278 List<PropertyDefinition> properties = new ArrayList<>();
2279 PropertyDefinition propertyDefinition = new PropertyDefinition();
2280 propertyDefinition.setName("tosca_simple_yaml_1_1");
2281 properties.add(propertyDefinition);
2282 newResource.setProperties(properties);
2286 protected Map<String, InputDefinition> getCurrPropertiesMap() {
2287 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2288 InputDefinition inputDefinition = new InputDefinition();
2289 inputDefinition.setName("inputDefinitionName");
2290 inputDefinition.setUniqueId("uniqueId");
2291 inputDefinition.setType("inputDefinitionType");
2292 currPropertiesMap.put("propertyInfoName", inputDefinition);
2293 return currPropertiesMap;
2296 protected List<UploadPropInfo> getPropertyList() {
2297 List<UploadPropInfo> propertyList = new ArrayList<>();
2298 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2299 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2300 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2301 getInputValueDataDefinition.setInputName("inputDefinitionName");
2302 get_input.add(getInputValueDataDefinition);
2303 UploadPropInfo propertyInfo = new UploadPropInfo();
2304 propertyInfo.setValue("value");
2305 propertyInfo.setGet_input(get_input);
2306 propertyInfo.setName("propertyInfoName");
2307 propertyList.add(propertyInfo);
2308 return propertyList;
2311 private Map<String, NodeTypeInfo> getNodeTypesInfo() {
2312 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2313 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2314 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2315 nodeTypeInfo.setNested(true);
2316 nodeTypeInfo.setTemplateFileName("templateFileName");
2317 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2318 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2319 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2320 return nodeTypesInfo;
2323 private Map<String, Object> getNodeTypes() {
2324 Map<String, Object> nodeTypesInfo = new HashMap<>();
2325 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2326 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2327 nodeTypeInfo.setNested(true);
2328 nodeTypeInfo.setTemplateFileName("templateFileName");
2329 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2330 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2331 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2332 return nodeTypesInfo;
2335 private Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap() {
2336 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
2337 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2338 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
2339 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2340 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
2341 requirementsNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2342 uploadResInstancesMap.put("zxjTestImportServiceAb", uploadComponentInstanceInfo);
2343 return uploadResInstancesMap;
2346 protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties() {
2347 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
2348 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
2349 UploadPropInfo uploadPropInfo = new UploadPropInfo();
2350 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2351 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2352 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2353 get_input.add(getInputValueDataDefinition);
2354 uploadPropInfo.setName("propertiesName");
2355 uploadPropInfo.setValue("value");
2356 uploadPropInfo.setGet_input(get_input);
2357 uploadPropInfoList.add(uploadPropInfo);
2358 properties.put("uploadComponentInstanceInfo", uploadPropInfoList);
2362 protected List<PropertyDefinition> getProperties() {
2363 List<PropertyDefinition> properties = new ArrayList<>();
2364 PropertyDefinition propertyDefinition = new PropertyDefinition();
2365 propertyDefinition.setName("propertiesName");
2366 properties.add(propertyDefinition);
2370 protected Map<String, List<UploadReqInfo>> gerRequirements() {
2371 Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
2372 String requirementName = "tosca.capabilities.Node";
2373 List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
2374 UploadReqInfo uploadReqInfo = new UploadReqInfo();
2375 uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
2376 uploadReqInfoMap.put(requirementName, uploadReqInfoList);
2377 return uploadReqInfoMap;
2380 protected ComponentParametersView createComponentParametersView() {
2381 ComponentParametersView parametersView = new ComponentParametersView();
2382 parametersView.disableAll();
2383 parametersView.setIgnoreComponentInstances(false);
2384 parametersView.setIgnoreComponentInstancesProperties(false);
2385 parametersView.setIgnoreCapabilities(false);
2386 parametersView.setIgnoreRequirements(false);
2387 parametersView.setIgnoreGroups(false);
2388 return parametersView;
2391 protected Map<String, byte[]> crateCsarFromPayload() {
2392 String payloadName = "valid_vf.csar";
2393 String rootPath = System.getProperty("user.dir");
2397 Map<String, byte[]> returnValue = null;
2399 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2400 data = Files.readAllBytes(path);
2401 payloadData = Base64.encodeBase64String(data);
2402 UploadResourceInfo resourceInfo = new UploadResourceInfo();
2403 resourceInfo.setPayloadName(payloadName);
2404 resourceInfo.setPayloadData(payloadData);
2405 Method privateMethod = null;
2406 privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
2407 privateMethod.setAccessible(true);
2408 returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
2409 } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException |
2410 InvocationTargetException e) {
2411 e.printStackTrace();
2416 protected List<ComponentInstance> creatComponentInstances() {
2417 List<ComponentInstance> componentInstances = new ArrayList<>();
2418 ComponentInstance componentInstance = new ComponentInstance();
2419 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2420 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
2421 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
2422 capabilityDefinition.setName("mme_ipu_vdu.feature");
2423 capabilityDefinitionList.add(capabilityDefinition);
2424 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
2426 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2427 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2428 RequirementDefinition requirementDefinition = new RequirementDefinition();
2429 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
2430 requirementDefinitionList.add(requirementDefinition);
2431 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
2432 componentInstance.setRequirements(requirements);
2433 componentInstance.setCapabilities(capabilities);
2434 componentInstance.setUniqueId("uniqueId");
2435 componentInstance.setComponentUid("componentUid");
2436 componentInstance.setName("zxjTestImportServiceAb");
2437 componentInstance.setNormalizedName("zxjTestImportServiceAb");
2438 componentInstance.setProperties(getProperties());
2439 componentInstances.add(componentInstance);
2440 return componentInstances;
2443 private CreateServiceFromYamlParameter getCsfyp() {
2444 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
2445 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2446 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2448 csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
2449 csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
2450 csfyp.setCreatedArtifacts(createdArtifacts);
2451 csfyp.setInTransaction(true);
2452 csfyp.setShouldLock(true);
2453 csfyp.setCsarInfo(getCsarInfo());
2454 csfyp.setParsedToscaYamlInfo(getParsedToscaYamlInfo());
2455 csfyp.setNodeTypesInfo(nodeTypesInfo);
2456 csfyp.setYamlName("group.yml");
2460 private ParsedToscaYamlInfo getParsedToscaYamlInfo() {
2461 ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
2462 Map<String, InputDefinition> inputs = new HashMap<>();
2463 Map<String, UploadComponentInstanceInfo> instances = new HashMap<>();
2464 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2465 instances.put("instances", uploadComponentInstanceInfo);
2466 Map<String, GroupDefinition> groups = new HashMap<>();
2467 Map<String, PolicyDefinition> policies = new HashMap<>();
2468 parsedToscaYamlInfo.setGroups(groups);
2469 parsedToscaYamlInfo.setInputs(inputs);
2470 parsedToscaYamlInfo.setInstances(instances);
2471 parsedToscaYamlInfo.setPolicies(policies);
2472 return parsedToscaYamlInfo;
2475 String getMainTemplateContent(String fileName) {
2476 String mainTemplateContent = null;
2478 mainTemplateContent = loadFileNameToJsonString(fileName);
2479 } catch (IOException e) {
2480 e.printStackTrace();
2482 return mainTemplateContent;
2485 protected ServiceCsarInfo getCsarInfo() {
2486 String csarUuid = "0010";
2487 User user = new User("jh0003");
2490 File csarFile = new File(
2491 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
2492 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
2494 String vfReousrceName = "resouceName";
2495 String mainTemplateName = "Definitions/service_import_template.yml";
2497 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
2498 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
2499 assertNotNull(mainTemplateService);
2500 final String mainTemplateContent = new String(mainTemplateService);
2502 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false, mock(ModelOperation.class));
2503 } catch (URISyntaxException | ZipException e) {
2509 private ImmutablePair<String, byte[]> getNodeType() {
2511 File resource = new File(
2512 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("node-types/resource-Extcp-template.yml").toURI());
2513 byte[] extcpResource = Files.readAllBytes(resource.toPath());
2515 return new ImmutablePair<>("org.openecomp.resource.cp.extCP", extcpResource);
2516 } catch (URISyntaxException | IOException e) {
2522 protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo() {
2523 String artifactName = "artifactName", path = "/src/test/resources/valid_vf.csar", artifactType = "AAI_SERVICE_MODEL";
2524 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
2525 String rootPath = System.getProperty("user.dir");
2527 byte[] data = new byte[0];
2528 path2 = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2530 data = Files.readAllBytes(path2);
2531 } catch (IOException e) {
2532 e.printStackTrace();
2534 String artifactUniqueId = "artifactUniqueId";
2535 boolean isFromCsar = true;
2536 CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
2537 path, artifactType, artifactGroupType, data, artifactUniqueId, isFromCsar);
2538 return nonMetaArtifactInfo;
2542 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2543 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2544 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2545 assertParseResponse(actualResponse, expectedStatus, variables);
2548 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2549 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2550 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2551 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());