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())).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 // when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), any(), any(Service.class)))
217 // .thenReturn(getParsedToscaYamlInfo());
218 when(serviceBusinessLogic.lockComponentByName(newService.getSystemName(), oldService, CREATE_RESOURCE)).thenReturn(Either.left(true));
219 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
220 when(serviceImportParseLogic.createServiceTransaction(oldService, csarInfo.getModifier(), false)).thenReturn(newService);
221 when(serviceImportParseLogic.createInputsOnService(eq(oldService), anyMap())).thenReturn(newService);
222 Assertions.assertDoesNotThrow(() -> {
223 when(serviceImportParseLogic.createSubstitutionFilterOnService(eq(oldService), any())).thenReturn(newService);
225 when(serviceImportParseLogic.getNodeTypesFromTemplate(anyMap())).thenReturn(getNodeTypes());
226 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class), anyMap(), any(Service.class),
227 anyBoolean(), any(), anyList(), anyBoolean(), any(CsarInfo.class), anyBoolean())).thenReturn(
228 new ImmutablePair<>(resource, ActionStatus.OK));
229 when(serviceImportParseLogic.getComponentWithInstancesFilter()).thenReturn(new ComponentParametersView());
230 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
231 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(new ComponentParametersView());
232 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
233 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
234 any(ComponentInstance.class), anyString())).thenReturn(Either.left(new RequirementDefinition()));
235 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class), any(ComponentInstance.class),
236 any(UploadReqInfo.class))).thenReturn(new CapabilityDefinition());
237 when(componentsUtils.getResponseFormat(eq(ActionStatus.OK), anyString())).thenReturn(new ResponseFormat(200));
238 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
239 doNothing().when(compositionBusinessLogic).setPositionsForComponentInstances(any(Service.class), anyString());
240 when(groupBusinessLogic.validateUpdateVfGroupNames(anyMap(), anyString())).thenReturn(Either.left(new HashMap<>()));
241 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean()))
242 .thenReturn(Either.left(newService));
243 when(serviceImportParseLogic.getServiceWithGroups(anyString())).thenReturn(newService);
244 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
245 when(graphLockOperation.unlockComponentByName(anyString(), anyString(), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
246 when(serviceImportParseLogic.createOutputsOnService(any(Service.class), any(), anyString())).thenReturn(newService);
247 when(toscaOperationFacade.updateInputsToComponent(anyList(), eq(newService.getUniqueId()))).thenReturn(Either.left(new ArrayList<>()));
249 when(applicationDataTypeCache.get(any(), contains("tosca.datatypes.test_"))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
250 DataTypeDefinition typeToBeUpdated = new DataTypeDefinition();
251 List<PropertyDefinition> properties = new ArrayList<>();
252 PropertyDefinition nameProperty = new PropertyDefinition();
253 nameProperty.setName("name");
254 nameProperty.setType("string");
255 properties.add(nameProperty);
256 PropertyDefinition versionProperty = new PropertyDefinition();
257 versionProperty.setName("version");
258 versionProperty.setType("string");
259 properties.add(versionProperty);
260 typeToBeUpdated.setProperties(properties);
261 when(applicationDataTypeCache.get(any(), eq("onap.datatypes.ToscaConceptIdentifier.datatype"))).thenReturn(Either.left(typeToBeUpdated));
262 when(applicationDataTypeCache.get(any(), matches("^((?!(tosca.datatypes.test_|onap.datatypes.ToscaConceptIdentifier)).)*$"))).thenReturn(Either.left(new DataTypeDefinition()));
264 when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.testartifacts.Name"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
265 when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.artifacts"))).thenReturn(Either.left(null));
267 when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces"))).thenReturn(Either.left(new InterfaceDefinition()));
268 when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces.test"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
271 when(capabilityTypeOperation.getCapabilityType(anyString()))
272 .thenReturn(Either.left(new CapabilityTypeDefinition()));
273 when(capabilityTypeOperation.getCapabilityType(contains("tosca.testcapabilitytypes.Name")))
274 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
276 when(toscaOperationFacade.getLatestByToscaResourceName(contains("org.openecomp.resource"), isNull()))
277 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
278 when(toscaOperationFacade.getLatestByToscaResourceName(contains("tosca.nodes."), isNull()))
279 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
280 when(toscaOperationFacade.getLatestByToscaResourceName(updatedNodeType, null)).thenReturn(Either.left(resource));
281 when(artifactsBusinessLogic.handleDownloadRequestById(resourceUniqueId, artifactUniqueId, user.getUserId(), ComponentTypeEnum.RESOURCE, null, null))
282 .thenReturn(resourceTemplate);
283 when(toscaOperationFacade.updatePropertyOfComponent(eq(oldService), any(PropertyDefinition.class))).thenReturn(Either.left(null));
284 when(toscaOperationFacade.updateComponentInstancePropsToComponent(anyMap(), anyString())).thenReturn(Either.left(null));
285 when(groupTypeOperation.getGroupTypeByUid(anyString())).thenReturn(Either.left(new GroupTypeDefinition()));
287 Service result = sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
288 assertNotNull(result);
289 assertNotNull(result.getComponentInstances());
290 assertEquals(1, result.getComponentInstances().size());
291 assertNotNull(result.getComponentInstances().get(0));
292 assertNotNull(result.getComponentInstances().get(0).getCapabilities());
293 assertEquals(1, result.getComponentInstances().get(0).getCapabilities().size());
294 assertNotNull(result.getComponentInstances().get(0).getRequirements());
295 assertEquals(1, result.getComponentInstances().get(0).getRequirements().size());
296 assertNotNull(result.getCategories());
297 assertEquals(1, result.getCategories().size());
299 ArgumentCaptor<String> yaml = ArgumentCaptor.forClass(String.class);
300 verify(dataTypeBusinessLogic).createDataTypeFromYaml(yaml.capture(), isNull(), anyBoolean());
301 Map<String, Object> yamlMap = new Yaml().load(yaml.getValue());
302 assertEquals(3, yamlMap.size());
303 assertNotNull(yamlMap.get("tosca.datatypes.test_a"));
304 assertNotNull(yamlMap.get("tosca.datatypes.test_b"));
305 assertNotNull(yamlMap.get("onap.datatypes.ToscaConceptIdentifier"));
307 ArgumentCaptor<String> artifactTypes = ArgumentCaptor.forClass(String.class);
308 verify(artifactTypeImportManager).createArtifactTypes(artifactTypes.capture(),isNull(), anyBoolean());
309 Map<String, Object> artifactTypesMap = new Yaml().load(artifactTypes.getValue());
310 assertEquals(1, artifactTypesMap.size());
311 assertNotNull(artifactTypesMap.get("tosca.testartifacts.Name"));
313 ArgumentCaptor<String> capabilityTypes = ArgumentCaptor.forClass(String.class);
314 verify(capabilityTypeImportManager).createCapabilityTypes(
315 capabilityTypes.capture(),
318 Map<String, Object> capabilityTypesMap = new Yaml().load(capabilityTypes.getValue());
319 assertEquals(1, capabilityTypesMap.size());
320 assertNotNull(capabilityTypesMap.get("tosca.testcapabilitytypes.Name"));
322 ArgumentCaptor<Map<String, Object>> nodeTypes = ArgumentCaptor.forClass(Map.class);
323 verify(resourceImportManager).importAllNormativeResource(nodeTypes.capture(), any(), any(), any(),
324 anyBoolean(), anyBoolean());
325 Map<String, Object> nodeTypesMap = nodeTypes.getValue();
326 Map<String, Object> newUpdatedNodeType = (Map<String, Object>) nodeTypesMap.get(updatedNodeType);
327 assertEquals(8, ((Map<String, Object>) newUpdatedNodeType.get("properties")).size());
328 Assertions.assertNull(newUpdatedNodeType.get("attributes"));
329 assertEquals(3, ((List<Map<String, Object>>) newUpdatedNodeType.get("requirements")).size());
330 assertEquals(1, ((Map<String, Object>) newUpdatedNodeType.get("capabilities")).size());
331 assertEquals(2, ((Map<String, Object>) newUpdatedNodeType.get("interfaces")).size());
333 ArgumentCaptor<String> interfaceTypes = ArgumentCaptor.forClass(String.class);
334 verify(interfaceLifecycleTypeImportManager).createLifecycleTypes(interfaceTypes.capture(), any(), anyBoolean());
335 Map<String, Object> yamlInterfaceMap = new Yaml().load(interfaceTypes.getValue());
336 assertEquals(3, yamlInterfaceMap.size());
337 assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Attach"));
338 assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Detach"));
339 assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Reconfigure"));
344 void testCreateService_Fail_NotFoundNodeTypesArtifacts() {
345 Service oldService = createServiceObject(true);
346 String payloadName = "valid_vf";
347 Map<String, byte[]> payload = crateCsarFromPayload();
348 Service newService = createServiceObject(true);
350 when(serviceBusinessLogic.validateServiceBeforeCreate(any(Service.class), any(User.class), any(AuditingActionEnum.class)))
351 .thenReturn(Either.left(newService));
352 when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
353 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString())).thenReturn(getCsarInfo());
354 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
355 .thenReturn(Either.right(ActionStatus.GENERAL_ERROR));
356 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), anyString(),
357 any(Service.class))).thenReturn(getParsedToscaYamlInfo());
359 Assertions.assertThrows(ComponentException.class,
360 () -> sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName));
364 void testCreateServiceFromCsar() {
365 Service oldService = createServiceObject(true);
366 String csarUUID = "valid_vf";
367 Map<String, byte[]> payload = crateCsarFromPayload();
368 ServiceCsarInfo csarInfo = getCsarInfo();
369 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> map =
372 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class),
373 any(Map.class), anyString())).thenReturn(csarInfo);
374 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class),
375 any(Service.class))).thenReturn(Either.left(map));
376 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromCsar(oldService,
377 user, payload, csarUUID));
381 void testCreateServiceFromYaml() {
382 Service oldService = createServiceObject(true);
383 Resource resource = createOldResource();
384 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
385 String yamlName = "group.yml";
386 ServiceCsarInfo csarInfo = getCsarInfo();
387 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
388 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
390 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
391 Map<String, Object> map = new HashMap<>();
392 map.put("tosca_definitions_version", "123");
393 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
394 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
395 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
396 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(Map.class),
397 eq(csarInfo), anyString(), any(Component.class))).thenReturn(parsedToscaYamlInfo);
398 when(serviceBusinessLogic.lockComponentByName(anyString(), any(Service.class), anyString()))
399 .thenReturn(Either.left(true));
401 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromYaml(oldService,
402 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
403 nodeTypesArtifactsToCreate, false, true, nodeName, user.getUserId()));
407 void testCreateServiceAndRIsFromYaml() {
408 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
409 Service oldService = createServiceObject(true);
410 Resource resource = createOldResource();
411 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
412 CreateServiceFromYamlParameter csfyp = getCsfyp();
413 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
414 Map<String, Object> map = new HashMap<>();
415 map.put("tosca_definitions_version", "123");
416 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
417 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
418 csfyp.setNodeTypesInfo(nodeTypesInfo);
419 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
420 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
421 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
422 false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId()));
426 void testCreateServiceAndRIsFromYamlShoudLook() {
427 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
428 Service oldService = createServiceObject(true);
429 Resource resource = createOldResource();
430 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
431 CreateServiceFromYamlParameter csfyp = getCsfyp();
432 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
433 Map<String, Object> map = new HashMap<>();
434 map.put("tosca_definitions_version", "123");
435 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
436 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
437 csfyp.setNodeTypesInfo(nodeTypesInfo);
438 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
439 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
440 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
441 false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId()));
445 void testCreateOrUpdateArtifacts() {
446 ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
447 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
448 String yamlFileName = "group.yml";
449 CsarInfo csarInfo = getCsarInfo();
450 Resource preparedResource = createParseResourceObject(false);
451 preparedResource.setResourceType(ResourceTypeEnum.VF);
452 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
453 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
454 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
455 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
456 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
457 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
458 artifactDefinition.setArtifactName("artifactName");
459 artifactDefinitions.add(artifactDefinition);
460 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
461 artifactDefinitions);
462 nodeTypesArtifactsToHandle.put(nodeName, enumListEnumMap);
463 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
464 nodeTypeInfoToUpdateArtifacts.setNodeName(nodeName);
465 nodeTypeInfoToUpdateArtifacts.setNodeTypesArtifactsToHandle(nodeTypesArtifactsToHandle);
467 Assertions.assertNotNull(
468 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
469 preparedResource, nodeTypeInfoToUpdateArtifacts, true, true)
474 void testHandleVfCsarArtifacts() {
475 Resource resource = createParseResourceObject(true);
476 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
477 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
478 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
479 artifactDefinition.setUniqueId("uniqueId");
480 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
481 resource.setDeploymentArtifacts(deploymentArtifacts);
482 CsarInfo csarInfo = getCsarInfo();
483 Map<String, byte[]> csar = new HashMap<>();
484 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
485 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
486 csar.put(csarKey, artifactsMetaBytes);
487 csarInfo.setCsar(csar);
488 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
489 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
490 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
491 when(csarArtifactsAndGroupsBusinessLogic
492 .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
493 anyList())).thenReturn(Either.left(resource));
494 Assertions.assertNotNull(
495 sIBL.handleVfCsarArtifacts(resource,
496 csarInfo, createdArtifacts, artifactOperation, true, true));
500 void testHandleVfCsarArtifactsGetToscaElement() {
501 Resource resource = createParseResourceObject(true);
502 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
503 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
504 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
505 artifactDefinition.setUniqueId("uniqueId");
506 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
507 resource.setDeploymentArtifacts(deploymentArtifacts);
508 CsarInfo csarInfo = getCsarInfo();
509 Map<String, byte[]> csar = new HashMap<>();
510 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
511 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
512 csar.put(csarKey, artifactsMetaBytes);
513 csarInfo.setCsar(csar);
514 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
515 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
516 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
517 when(csarArtifactsAndGroupsBusinessLogic
518 .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
519 anyList())).thenReturn(Either.left(resource));
520 Assertions.assertNotNull(
521 sIBL.handleVfCsarArtifacts(resource,
522 csarInfo, createdArtifacts, artifactOperation, true, true));
526 void testCreateOrUpdateSingleNonMetaArtifactToComstants() {
527 Resource resource = createParseResourceObject(false);
528 CsarInfo csarInfo = getCsarInfo();
529 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
530 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
531 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
532 artifactDefinition.setArtifactName("artifactDefinition");
533 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
534 resource.setDeploymentArtifacts(deploymentArtifacts);
535 Assertions.assertNotNull(resource);
536 Assertions.assertNotNull(csarInfo);
537 sIBL.createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, true, true);
542 void testCreateOrUpdateNonMetaArtifacts() {
543 CsarInfo csarInfo = getCsarInfo();
544 Resource resource = createParseResourceObject(false);
545 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
546 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
548 Either<Resource, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo, resource,
549 createdArtifacts, true, true, artifactOperation);
550 assertEquals(result.left().value(), resource);
554 void testFindVfCsarArtifactsToHandle() {
555 Resource resource = createParseResourceObject(false);
556 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
557 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
558 artifactDefinition.setArtifactName("artifactDefinition");
559 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
560 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
561 artifacts.put("artifacts", artifactDefinition);
562 List<GroupDefinition> groups = new ArrayList<>();
563 GroupDefinition groupDefinition = new GroupDefinition();
564 groupDefinition.setUniqueId("groupDefinitionUniqueId");
565 groupDefinition.setName("groupDefinition");
566 groups.add(groupDefinition);
567 resource.setDeploymentArtifacts(deploymentArtifacts);
568 resource.setArtifacts(artifacts);
569 resource.setGroups(groups);
570 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
572 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
573 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(resource, artifactPathAndNameList, user);
574 assertNotNull(result.left().value());
578 void testOrganizeVfCsarArtifactsByArtifactOperation() {
579 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
580 artifactPathAndNameList.add(getNonMetaArtifactInfo());
581 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
582 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
583 artifactDefinition.setArtifactName("artifactName");
584 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
585 artifactDefinition.setArtifactChecksum("artifactChecksum");
586 existingArtifactsToHandle.add(artifactDefinition);
587 Resource resource = createParseResourceObject(false);
589 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
590 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
591 existingArtifactsToHandle,
593 assertNotNull(enumMapResponseFormatEither.left().value());
597 void testOrganizeVfCsarArtifactsByArtifactOperationElse() {
598 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
599 artifactPathAndNameList.add(getNonMetaArtifactInfo());
600 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
601 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
602 artifactDefinition.setArtifactName("artifactName");
603 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
604 artifactDefinition.setArtifactChecksum("artifactChecksum");
605 existingArtifactsToHandle.add(artifactDefinition);
606 Resource resource = createParseResourceObject(false);
607 Assertions.assertNotNull(
608 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource,
613 void testProcessCsarArtifacts() {
614 CsarInfo csarInfo = getCsarInfo();
615 Resource resource = createParseResourceObject(false);
616 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
617 Either<Resource, ResponseFormat> resStatus = Either.left(resource);
618 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
619 artifactPathAndNameList.add(getNonMetaArtifactInfo());
620 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
621 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
622 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactPathAndNameList);
623 Assertions.assertNotNull(
624 sIBL.processCsarArtifacts(csarInfo,
625 resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
629 void testCreateOrUpdateSingleNonMetaArtifact() {
630 Resource resource = createParseResourceObject(false);
631 CsarInfo csarInfo = getCsarInfo();
632 Map<String, byte[]> csar = csarInfo.getCsar();
633 String rootPath = System.getProperty("user.dir");
635 byte[] data = new byte[0];
636 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
638 data = Files.readAllBytes(path);
639 } catch (IOException e) {
642 csar.put("valid_vf.csar", data);
643 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
644 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
645 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
646 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
647 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
648 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
649 artifactDefinition.setArtifactName("artifactName");
650 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
651 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Resource.class), any(User.class),
652 any(Map.class), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
653 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
654 .thenReturn(Either.left(artifactDefinition));
655 Assertions.assertNotNull(
656 sIBL.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath,
657 artifactFileName, artifactType, artifactGroupType, artifactLabel,
658 artifactDisplayName, artifactDescription, artifactId, artifactOperation,
659 createdArtifacts, true, true, true));
663 void testCreateOrUpdateServiceArtifacts() throws IOException {
664 ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
665 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
666 String yamlFileName = "group.yml";
667 CsarInfo csarInfo = getCsarInfo();
668 Map<String, byte[]> csar = new HashMap<>();
669 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
670 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
671 csar.put(csarKey, artifactsMetaBytes);
672 csarInfo.setCsar(csar);
673 Service preparedService = createServiceObject(true);
674 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
675 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
676 artifactDefinition.setArtifactName("artifactDefinition");
677 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
678 preparedService.setDeploymentArtifacts(deploymentArtifacts);
679 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
680 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
681 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
683 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(createServiceObject(true)));
684 when(csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
685 anyString(), anyString(), anyList(), anyBoolean(), anyBoolean())).thenReturn(Either.left(preparedService));
686 Assertions.assertNotNull(
687 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
688 preparedService, nodeTypeInfoToUpdateArtifacts, true, true));
692 void testHandleVfCsarServiceArtifacts() {
693 Service service = createServiceObject(true);
694 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
695 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
696 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
697 artifactDefinition.setUniqueId("uniqueId");
698 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
699 service.setDeploymentArtifacts(deploymentArtifacts);
700 CsarInfo csarInfo = getCsarInfo();
701 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
702 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
703 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
704 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean())).thenReturn(
705 Either.left(service));
706 Assertions.assertNotNull(
707 sIBL.handleVfCsarArtifacts(service, csarInfo, createdArtifacts, artifactOperation, true, true));
711 void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
712 Service service = createServiceObject(true);
713 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
714 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
715 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
716 artifactDefinition.setUniqueId("uniqueId");
717 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
718 service.setDeploymentArtifacts(deploymentArtifacts);
719 CsarInfo csarInfo = getCsarInfo();
720 Map<String, byte[]> csar = new HashMap<>();
721 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
722 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
723 csar.put(csarKey, artifactsMetaBytes);
724 csarInfo.setCsar(csar);
725 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
726 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
727 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
728 when(csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
729 anyString(), anyString(), anyList())).thenReturn(Either.left(service));
730 Assertions.assertNotNull(
731 sIBL.handleVfCsarArtifacts(service,
732 csarInfo, createdArtifacts, artifactOperation, true, true));
736 void testCreateOrUpdateNonMetaServiceArtifacts() {
737 CsarInfo csarInfo = getCsarInfo();
738 Service service = createServiceObject(true);
739 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
740 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
742 Either<Service, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo,
743 service, createdArtifacts, true, true, artifactOperation);
744 assertEquals(result.left().value(), service);
748 void testFindServiceCsarArtifactsToHandle() {
749 Service service = createServiceObject(true);
750 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
751 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
752 artifactDefinition.setArtifactName("artifactDefinition");
753 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
754 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
755 artifacts.put("artifacts", artifactDefinition);
756 List<GroupDefinition> groups = new ArrayList<>();
757 GroupDefinition groupDefinition = new GroupDefinition();
758 groupDefinition.setUniqueId("groupDefinitionUniqueId");
759 groupDefinition.setName("groupDefinition");
760 groups.add(groupDefinition);
761 service.setDeploymentArtifacts(deploymentArtifacts);
762 service.setArtifacts(artifacts);
763 service.setGroups(groups);
764 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
766 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
767 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
768 assertNotNull(result.left().value());
772 void testOrganizeVfCsarArtifactsByServiceArtifactOperation() {
773 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
774 artifactPathAndNameList.add(getNonMetaArtifactInfo());
775 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
776 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
777 artifactDefinition.setArtifactName("artifactName");
778 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
779 artifactDefinition.setArtifactChecksum("artifactChecksum");
780 existingArtifactsToHandle.add(artifactDefinition);
781 Service service = createServiceObject(true);
783 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
784 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
785 existingArtifactsToHandle, service, user);
786 assertNotNull(enumMapResponseFormatEither.left().value());
790 void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse() {
791 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
792 artifactPathAndNameList.add(getNonMetaArtifactInfo());
793 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
794 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
795 artifactDefinition.setArtifactName("artifactName");
796 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
797 artifactDefinition.setArtifactChecksum("artifactChecksum");
798 existingArtifactsToHandle.add(artifactDefinition);
799 Service service = createServiceObject(true);
800 Assertions.assertNotNull(
801 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user));
806 void testProcessServiceCsarArtifacts() {
807 CsarInfo csarInfo = getCsarInfo();
808 Service service = createServiceObject(true);
809 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
810 Either<Service, ResponseFormat> resStatus = Either.left(service);
811 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
812 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
813 List<CsarUtils.NonMetaArtifactInfo> objects = new ArrayList<>();
814 objects.add(getNonMetaArtifactInfo());
815 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, objects);
816 Assertions.assertNotNull(
817 sIBL.processCsarArtifacts(csarInfo, service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
821 void testGetValidArtifactNames() {
822 CsarInfo csarInfo = getCsarInfo();
823 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
824 Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIBL.getValidArtifactNames(csarInfo,
825 collectedWarningMessages);
826 assertNotNull(result.left().value());
830 void testCreateOrUpdateSingleNonMetaServiceArtifact() {
831 Service service = createServiceObject(true);
832 CsarInfo csarInfo = getCsarInfo();
833 Map<String, byte[]> csar = csarInfo.getCsar();
834 String rootPath = System.getProperty("user.dir");
836 byte[] data = new byte[0];
837 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
839 data = Files.readAllBytes(path);
840 } catch (IOException e) {
843 csar.put("valid_vf.csar", data);
844 csarInfo.setCsar(csar);
845 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
846 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
847 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
848 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
849 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
850 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
851 artifactDefinition.setArtifactName("artifactName");
852 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
853 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Service.class), any(User.class),
854 anyMap(), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
855 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
856 .thenReturn(Either.left(artifactDefinition));
857 Assertions.assertNotNull(
858 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
859 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
860 artifactDescription, artifactId, artifactOperation, createdArtifacts,
865 void testCreateOrUpdateSingleNonMetaServiceArtifactNull() {
866 Service service = createServiceObject(true);
867 CsarInfo csarInfo = getCsarInfo();
868 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
869 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
870 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
871 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
872 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
873 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
874 .thenReturn(Either.left(artifactDefinition));
875 Assertions.assertNotNull(
876 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
877 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
878 artifactDescription, artifactId, artifactOperation, createdArtifacts,
883 void testCreateGroupsOnResource() {
884 Service service = createServiceObject(true);
885 Map<String, GroupDefinition> groups = new HashMap<>();
886 Assertions.assertNotNull(sIBL.createGroupsOnResource(service, groups));
890 void testCreateGroupsOnResourceNull() {
891 Service service = createServiceObject(true);
892 Map<String, GroupDefinition> groups = new HashMap<>();
893 Assertions.assertNotNull(
894 sIBL.createGroupsOnResource(service, groups));
898 void testUpdateGroupsMembersUsingResource() {
899 Service service = createServiceObject(true);
900 Map<String, GroupDefinition> groups = getGroups();
902 Assertions.assertNotNull(
903 sIBL.updateGroupsMembersUsingResource(groups, service));
907 void testUpdateGroupsMembersUsingResource_left() {
908 Service service = createServiceObject(true);
909 Map<String, GroupDefinition> groups = getGroups();
911 Assertions.assertNotNull(
912 sIBL.updateGroupsMembersUsingResource(groups, service));
916 void testCreateRIAndRelationsFromResourceYaml() throws IOException {
917 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
918 String yamlName = "group.yml";
919 Resource resource = createParseResourceObject(true);
920 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
921 String topologyTemplateYaml = getMainTemplateContent();
922 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
924 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
925 Map<String, Object> map = new HashMap<>();
926 map.put("tosca_definitions_version", "123");
927 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
929 CsarInfo csarInfo = getCsarInfo();
930 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
932 Assertions.assertThrows(ComponentException.class, () -> sIBL
933 .createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
934 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
935 csarInfo, nodeTypesArtifactsToCreate, nodeName));
939 void testCreateResourceInstancesRelations() {
940 String yamlName = "group.yml";
941 Resource resource = createParseResourceObject(true);
942 resource.setComponentInstances(creatComponentInstances());
943 resource.setResourceType(ResourceTypeEnum.VF);
944 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
945 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
946 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
947 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
948 Assertions.assertThrows(ComponentException.class, () -> sIBL
949 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
953 void testCreateResourceInstancesRelations_Empty() {
954 String yamlName = "group.yml";
955 Resource resource = createParseResourceObject(true);
956 resource.setComponentInstances(creatComponentInstances());
957 resource.setResourceType(ResourceTypeEnum.VF);
958 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
959 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
960 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
961 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
962 Assertions.assertThrows(ComponentException.class, () -> sIBL
963 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
967 void testProcessComponentInstance1() {
968 String yamlName = "group.yml";
969 Resource resource = createParseResourceObject(true);
970 Resource originResource = createParseResourceObject(false);
971 originResource.setResourceType(ResourceTypeEnum.VF);
972 List<ComponentInstance> componentInstancesList = creatComponentInstances();
973 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
974 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
975 dataTypeDefinition.setName("dataTypeDefinitionName");
976 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
977 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
978 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
979 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
980 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
981 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
982 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
983 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
984 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
985 Map<String, Resource> originCompMap = new HashMap<>();
986 originCompMap.put("componentUid", originResource);
987 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
988 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
989 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
990 Assertions.assertNotNull(resource);
991 Assertions.assertNotNull(yamlName);
992 sIBL.processComponentInstance(yamlName, resource, componentInstancesList, allDataTypes.left().value(), instProperties,
993 instCapabilties, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes,
994 originCompMap, instInputs, instNodeFilter, null, uploadComponentInstanceInfo);
998 void testProcessComponentInstance_null() {
999 String yamlName = "group.yml";
1000 Resource resource = createParseResourceObject(true);
1001 Resource originResource = createParseResourceObject(false);
1002 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1003 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1004 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1005 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1006 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1007 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1008 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1009 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1010 Map<String, Resource> originCompMap = new HashMap<>();
1011 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1012 originCompMap.put("componentUid", originResource);
1013 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1014 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1015 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1017 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1018 resource, componentInstancesList, null, instProperties, instCapabilties,
1019 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1020 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1024 void testAddInputsValuesToRi() {
1025 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1026 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1027 List<UploadPropInfo> uploadPropInfoList = getPropertyList();
1028 properties.put("propertiesMap", uploadPropInfoList);
1029 uploadComponentInstanceInfo.setProperties(properties);
1030 Resource resource = createParseResourceObject(true);
1031 Resource originResource = createParseResourceObject(false);
1032 List<InputDefinition> inputs = new ArrayList<>();
1033 InputDefinition inputDefinition = new InputDefinition();
1034 inputDefinition.setName("inputDefinitionName");
1035 inputDefinition.setUniqueId("uniqueId");
1036 inputDefinition.setType("inputDefinitionType");
1037 inputs.add(inputDefinition);
1038 originResource.setInputs(inputs);
1039 ComponentInstance currentCompInstance = new ComponentInstance();
1040 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1041 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1042 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1043 dataTypeDefinition.setName("dataTypeDefinitionName");
1044 allDataTypes.put("dataTypeDefinitionMap", dataTypeDefinition);
1046 Assertions.assertThrows(ComponentException.class, () -> sIBL
1047 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1048 currentCompInstance, instInputs, allDataTypes));
1052 void testProcessProperty() {
1053 Resource resource = createParseResourceObject(true);
1054 List<InputDefinition> inputs = new ArrayList<>();
1055 InputDefinition inputDefinition = new InputDefinition();
1056 inputDefinition.setName("inputDefinitionName");
1057 inputDefinition.setUniqueId("uniqueId");
1058 inputDefinition.setType("inputDefinitionType");
1059 inputs.add(inputDefinition);
1060 resource.setInputs(inputs);
1061 ComponentInstance currentCompInstance = null;
1062 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1063 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1064 currPropertiesMap.put("propertyInfoName", inputDefinition);
1065 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1066 List<UploadPropInfo> propertyList = getPropertyList();
1067 Assertions.assertNotNull(resource);
1068 Assertions.assertNotNull(currPropertiesMap);
1069 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1073 void testHandleSubstitutionMappings() {
1074 Resource resource = createParseResourceObject(true);
1075 resource.setResourceType(ResourceTypeEnum.VF);
1076 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1077 when(toscaOperationFacade.getToscaFullElement(anyString()))
1078 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1080 Assertions.assertThrows(ComponentException.class,
1081 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1085 void testHandleSubstitutionMappings_left() {
1086 Resource resource = createParseResourceObject(true);
1087 resource.setResourceType(ResourceTypeEnum.VF);
1088 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1089 when(toscaOperationFacade.getToscaFullElement(anyString()))
1090 .thenReturn(Either.left(resource));
1092 Assertions.assertThrows(ComponentException.class,
1093 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1097 void testCreateResourceInstances() {
1098 String yamlName = "group.yml";
1099 Resource resource = createParseResourceObject(true);
1100 Resource originResource = createParseResourceObject(false);
1101 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1102 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
1103 nodesInfoValue.setName("zxjTestImportServiceAb");
1104 nodesInfoValue.setRequirements(gerRequirements());
1105 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1106 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1107 nodeNamespaceMap.put("resources", originResource);
1109 Assertions.assertThrows(ComponentException.class,
1110 () -> sIBL.createResourceInstances(yamlName, resource, uploadResInstancesMap, nodeNamespaceMap));
1114 void testHandleNodeTypes() throws IOException {
1115 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1116 String yamlName = "group.yml";
1117 Resource resource = createParseResourceObject(true);
1118 String topologyTemplateYaml = getMainTemplateContent();
1119 boolean needLock = true;
1120 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1121 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1122 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1123 Map<String, Object> map = new HashMap<>();
1124 map.put("tosca_definitions_version", "123");
1125 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1126 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1127 CsarInfo csarInfo = getCsarInfo();
1128 Assertions.assertNotNull(resource);
1130 sIBL.handleNodeTypes(yamlName, resource, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1131 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
1135 void testHandleNestedVfc1() {
1136 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1137 Resource resource = createParseResourceObject(false);
1138 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1139 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1140 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1141 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1142 nodeTypeInfo.setTemplateFileName("groups.yml");
1143 nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
1144 nodesInfo.put(nodeName, nodeTypeInfo);
1145 CsarInfo csarInfo = getCsarInfo();
1147 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(resource,
1148 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1152 void testHandleComplexVfc1() {
1153 Resource resource = createParseResourceObject(true);
1154 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1155 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1156 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1157 CsarInfo csarInfo = getCsarInfo();
1158 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1159 String yamlName = "group.yml";
1160 when(serviceImportParseLogic.buildValidComplexVfc(any(Resource.class), any(CsarInfo.class), anyString(),
1161 anyMap())).thenReturn(createParseResourceObject(false));
1162 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1163 .thenReturn(Either.left(resource));
1164 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class),
1165 anyBoolean())).thenReturn(Either.left(true));
1167 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleComplexVfc(resource,
1168 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName));
1172 void testCreateNodeTypes1() {
1173 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1174 String yamlName = "group.yml";
1175 Resource resource = createParseResourceObject(false);
1176 boolean needLock = true;
1177 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1178 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
1179 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1180 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
1181 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1182 artifactDefinition.setArtifactName("artifactName");
1183 artifactDefinitions.add(artifactDefinition);
1184 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
1185 artifactDefinitions);
1186 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
1187 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1188 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1189 Map<String, Object> map = new HashMap<>();
1190 map.put("tosca_definitions_version", "123");
1191 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1192 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1194 CsarInfo csarInfo = getCsarInfo();
1195 Map<String, Object> mapToConvert = new HashMap<>();
1196 Map<String, Object> nodeTypes = new HashMap<>();
1197 nodeTypes.put(nodeName, "");
1198 Assertions.assertNotNull(resource);
1200 sIBL.createNodeTypes(yamlName,
1201 resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1202 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
1206 void testCreateNodeTypeResourceFromYaml() throws IOException {
1207 String yamlName = "group.yml";
1208 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1209 Map<String, Object> nodeMap = new HashMap<>();
1210 nodeMap.put(nodeName, getGroupsYaml());
1211 Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
1212 Map<String, Object> mapToConvert = new HashedMap();
1213 Resource resourceVf = createParseResourceObject(false);
1214 boolean needLock = true;
1215 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
1216 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1217 boolean forceCertificationAllowed = true;
1218 CsarInfo csarInfo = getCsarInfo();
1219 boolean isNested = true;
1220 UploadResourceInfo resourceMetaData = new UploadResourceInfo();
1221 resourceMetaData.setResourceType("VFC");
1222 ImmutablePair<Resource, ActionStatus> immutablePair = new ImmutablePair<>(resourceVf, ActionStatus.CREATED);
1223 when(serviceImportParseLogic.fillResourceMetadata(anyString(), any(Resource.class), anyString(), any(User.class)))
1224 .thenReturn(resourceMetaData);
1225 when(serviceImportParseLogic.buildNodeTypeYaml(any(Map.Entry.class), anyMap(), anyString(), any(CsarInfo.class)))
1226 .thenReturn(nodeName);
1227 when(serviceBusinessLogic.validateUser(any(User.class), anyString(), any(Component.class), any(AuditingActionEnum.class),
1228 anyBoolean())).thenReturn(user);
1229 when(serviceImportParseLogic.createResourceFromNodeType(anyString(), any(UploadResourceInfo.class), any(User.class), anyBoolean(),
1231 anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
1232 anyString(), anyBoolean())).thenReturn(immutablePair);
1233 Assertions.assertNotNull(
1234 sIBL.createNodeTypeResourceFromYaml(yamlName, nodeNameValue, user, mapToConvert,
1235 resourceVf, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1236 forceCertificationAllowed, csarInfo, isNested));
1240 void testCreateRIAndRelationsFromYaml() {
1241 String yamlName = "group.yml";
1242 Service service = createServiceObject(true);
1243 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
1244 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1246 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1247 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1248 CsarInfo csarInfo = getCsarInfo();
1249 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1250 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1252 Assertions.assertNotNull(sIBL
1253 .createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap,
1254 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1255 csarInfo, nodeTypesArtifactsToCreate, nodeName));
1259 void testCreateServiceInstancesRelations() {
1260 String yamlName = "group.yml";
1261 Service service = createServiceObject(true);
1262 service.setComponentInstances(creatComponentInstances());
1263 Resource newResource = createNewResource();
1264 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1265 ComponentParametersView componentParametersView = new ComponentParametersView();
1266 RequirementDefinition requirementDefinition = new RequirementDefinition();
1267 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1268 capabilityDefinition.setName("as");
1269 capabilityDefinition.setUniqueId("1");
1270 capabilityDefinition.setOwnerId("2");
1271 ResponseFormat responseFormat = new ResponseFormat();
1272 responseFormat.setStatus(200);
1273 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(newResource);
1274 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1275 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(service));
1276 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1277 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1278 anyString())).thenReturn(Either.left(requirementDefinition));
1279 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1280 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1281 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1282 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
1283 Assertions.assertNotNull(sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
1287 void testCreateServiceInstancesRelations_Empty() {
1288 String yamlName = "group.yml";
1289 Service service = createServiceObject(true);
1290 service.setComponentInstances(creatComponentInstances());
1291 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1293 Assertions.assertThrows(ComponentException.class,
1294 () -> sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
1298 void testProcessComponentInstance() {
1299 String yamlName = "group.yml";
1300 Service service = createServiceObject(true);
1301 Resource originResource = createParseResourceObject(false);
1302 originResource.setResourceType(ResourceTypeEnum.VF);
1303 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1304 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
1305 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1306 dataTypeDefinition.setName("dataTypeDefinitionName");
1307 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
1308 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
1309 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1310 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1311 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1312 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1313 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1314 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1315 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1316 Map<String, Resource> originCompMap = new HashMap<>();
1317 originCompMap.put("componentUid", originResource);
1318 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1319 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1320 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
1321 Assertions.assertNotNull(service);
1323 sIBL.processComponentInstance(yamlName, service, componentInstancesList, allDataTypes.left().value(),
1324 instProperties, instCapabilties, instRequirements, instDeploymentArtifacts,
1325 instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, null,
1326 uploadComponentInstanceInfo);
1330 void testProcessComponentInstance_null2() {
1331 String yamlName = "group.yml";
1332 Service service = createServiceObject(true);
1333 Resource originResource = createParseResourceObject(false);
1334 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1335 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1336 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1337 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1338 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1339 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1340 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1341 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1342 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1343 Map<String, Resource> originCompMap = new HashMap<>();
1344 originCompMap.put("componentUid", originResource);
1345 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1346 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1347 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1349 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1350 service, componentInstancesList, null, instProperties, instCapabilties,
1351 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1352 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1356 void testAddInputsValuesToRi2() {
1357 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1358 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1359 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
1360 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1361 uploadPropInfo.setName("uploadPropInfo");
1362 uploadPropInfoList.add(uploadPropInfo);
1363 uploadPropInfoList.add(uploadPropInfo);
1364 properties.put("propertiesMap", uploadPropInfoList);
1365 uploadComponentInstanceInfo.setProperties(properties);
1366 Service resource = createServiceObject(true);
1367 Resource originResource = createParseResourceObject(false);
1368 List<InputDefinition> inputs = new ArrayList<>();
1369 InputDefinition inputDefinition = new InputDefinition();
1370 inputDefinition.setUniqueId("uniqueId");
1371 inputs.add(inputDefinition);
1372 originResource.setInputs(inputs);
1373 ComponentInstance currentCompInstance = new ComponentInstance();
1374 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1375 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1377 Assertions.assertThrows(ComponentException.class, () -> sIBL
1378 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1379 currentCompInstance, instInputs, allDataTypes));
1383 void testProcessProperty2() {
1384 Service resource = createServiceObject(true);
1385 List<InputDefinition> inputs = new ArrayList<>();
1386 ComponentInstance currentCompInstance = null;
1387 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1388 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1389 InputDefinition inputDefinition = new InputDefinition();
1390 inputDefinition.setName("inputDefinitionName");
1391 inputDefinition.setType("inputDefinitionType");
1392 inputs.add(inputDefinition);
1393 currPropertiesMap.put("propertyInfoName", inputDefinition);
1394 resource.setInputs(inputs);
1395 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1396 List<UploadPropInfo> propertyList = new ArrayList<>();
1397 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1398 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1399 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1400 getInputValueDataDefinition.setInputName("inputDefinitionName");
1401 get_input.add(getInputValueDataDefinition);
1402 UploadPropInfo propertyInfo = new UploadPropInfo();
1403 propertyInfo.setValue("value");
1404 propertyInfo.setGet_input(get_input);
1405 propertyInfo.setName("propertyInfoName");
1406 propertyList.add(propertyInfo);
1407 Assertions.assertNotNull(resource);
1409 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1413 void testProcessGetInput() {
1414 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1415 List<InputDefinition> inputs = new ArrayList<>();
1416 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1418 Assertions.assertThrows(ComponentException.class, () -> sIBL.processGetInput(getInputValues, inputs, getInputIndex));
1422 void testProcessGetInput_optional() {
1423 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1424 List<InputDefinition> inputs = new ArrayList<>();
1425 InputDefinition inputDefinition = new InputDefinition();
1426 inputDefinition.setUniqueId("uniqueId");
1427 inputDefinition.setName("InputName");
1428 inputs.add(inputDefinition);
1429 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1430 getInputIndex.setInputName("InputName");
1431 Assertions.assertNotNull(inputs);
1433 sIBL.processGetInput(getInputValues, inputs, getInputIndex);
1437 void testAddPropertyValuesToRi() {
1438 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1439 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1440 Resource resource = createParseResourceObject(true);
1441 List<InputDefinition> inputs = new ArrayList<>();
1442 InputDefinition inputDefinition = new InputDefinition();
1443 inputDefinition.setName("inputDefinitionName");
1444 inputDefinition.setUniqueId("uniqueId");
1445 inputDefinition.setType("inputDefinitionType");
1446 inputs.add(inputDefinition);
1447 resource.setInputs(inputs);
1448 Resource originResource = createParseResourceObject(false);
1449 originResource.setProperties(getProperties());
1450 ComponentInstance currentCompInstance = new ComponentInstance();
1451 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1452 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1453 ResponseFormat responseFormat = new ResponseFormat();
1454 when(serviceImportParseLogic.findInputByName(eq(inputs), any(GetInputValueDataDefinition.class)))
1455 .thenReturn(inputDefinition);
1456 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1457 Assertions.assertNotNull(
1458 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1459 currentCompInstance, instProperties, allDataTypes));
1463 void testAddPropertyValuesToRi_else() {
1464 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1465 Resource resource = createParseResourceObject(true);
1466 Resource originResource = createParseResourceObject(false);
1467 originResource.setProperties(getProperties());
1468 ComponentInstance currentCompInstance = new ComponentInstance();
1469 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1470 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1471 ResponseFormat responseFormat = new ResponseFormat();
1472 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1473 Assertions.assertNotNull(
1474 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
1475 instProperties, allDataTypes));
1479 void testAddPropertyValuesToRi2() {
1480 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1481 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1482 Service service = createServiceObject(true);
1483 List<InputDefinition> inputs = new ArrayList<>();
1484 InputDefinition inputDefinition = new InputDefinition();
1485 inputDefinition.setName("inputDefinitionName");
1486 inputDefinition.setUniqueId("uniqueId");
1487 inputDefinition.setType("inputDefinitionType");
1488 inputs.add(inputDefinition);
1489 service.setInputs(inputs);
1490 Resource originResource = createParseResourceObject(false);
1491 originResource.setProperties(getProperties());
1492 ComponentInstance currentCompInstance = new ComponentInstance();
1493 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1494 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1495 ResponseFormat responseFormat = new ResponseFormat();
1496 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1497 when(serviceImportParseLogic.findInputByName(anyList(), any(GetInputValueDataDefinition.class)))
1498 .thenReturn(inputDefinition);
1499 Assertions.assertNotNull(
1500 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource,
1501 currentCompInstance, instProperties, allDataTypes));
1505 void testAddPropertyValuesToRi2_else() {
1506 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1507 Service service = createServiceObject(true);
1508 Resource originResource = createParseResourceObject(false);
1509 originResource.setProperties(getProperties());
1510 ComponentInstance currentCompInstance = new ComponentInstance();
1511 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1512 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1513 ResponseFormat responseFormat = new ResponseFormat();
1514 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1515 Assertions.assertNotNull(
1516 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1517 instProperties, allDataTypes));
1521 void testProcessComponentInstanceCapabilities() {
1522 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1523 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1524 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1525 uploadComponentInstanceInfo.setCapabilities(getCapabilities());
1526 ComponentInstance currentCompInstance = new ComponentInstance();
1527 Resource originResource = createParseResourceObject(false);
1528 Assertions.assertNotNull(originResource);
1529 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1534 void testProcessComponentInstanceCapabilities_null() {
1535 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1536 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1537 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1538 ComponentInstance currentCompInstance = new ComponentInstance();
1539 Resource originResource = createParseResourceObject(false);
1540 Assertions.assertNotNull(originResource);
1542 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1547 void testUpdateCapabilityPropertiesValues() {
1548 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1549 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1550 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1551 Assertions.assertNull(allDataTypes);
1552 sIBL.updateCapabilityPropertiesValues(null, originCapabilities, newPropertiesMap);
1556 void testUpdatePropertyValues() {
1557 List<ComponentInstanceProperty> properties = new ArrayList<>();
1558 Map<String, UploadPropInfo> newProperties = new HashMap<>();
1559 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1560 Assertions.assertNotNull(allDataTypes);
1561 sIBL.updatePropertyValues(properties, newProperties, allDataTypes);
1565 void testUpdatePropertyValue() {
1566 ComponentInstanceProperty property = new ComponentInstanceProperty();
1567 property.setType("services");
1568 UploadPropInfo propertyInfo = new UploadPropInfo();
1569 propertyInfo.setValue("value");
1570 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1571 when(serviceBusinessLogic.validatePropValueBeforeCreate(any(IPropertyInputCommon.class), anyString(), anyBoolean(), anyMap())).thenReturn(
1573 Assertions.assertNotNull(sIBL.updatePropertyValue(property, propertyInfo, allDataTypes));
1577 void testGetOriginResource() {
1578 String yamlName = "group.yml";
1579 Map<String, Resource> originCompMap = new HashMap<>();
1580 ComponentInstance currentCompInstance = new ComponentInstance();
1581 currentCompInstance.setComponentUid("currentCompInstance");
1582 when(toscaOperationFacade.getToscaFullElement(anyString()))
1583 .thenReturn(Either.left(createParseResourceObject(true)));
1584 Assertions.assertNotNull(sIBL.getOriginResource(yamlName, originCompMap, currentCompInstance));
1588 void testUpdateCalculatedCapReqWithSubstitutionMappings() {
1589 Resource resource = createParseResourceObject(false);
1590 resource.setComponentInstances(creatComponentInstances());
1591 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1593 when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
1594 Assertions.assertNotNull(sIBL.updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap));
1598 void testFillUpdatedInstCapabilitiesRequirements() {
1599 List<ComponentInstance> componentInstances = creatComponentInstances();
1600 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1601 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1602 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
1603 Assertions.assertNotNull(componentInstances);
1605 sIBL.fillUpdatedInstCapabilitiesRequirements(componentInstances, uploadResInstancesMap,
1606 updatedInstCapabilities, updatedInstRequirement);
1610 void testFillUpdatedInstCapabilities() {
1611 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
1612 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1613 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1614 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1615 capabilityDefinition.setName("mme_ipu_vdu.feature");
1616 capabilityDefinitionList.add(capabilityDefinition);
1617 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
1618 ComponentInstance instance = new ComponentInstance();
1619 instance.setCapabilities(capabilities);
1620 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1621 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
1622 Assertions.assertNotNull(instance);
1624 sIBL.fillUpdatedInstCapabilities(updatedInstCapabilties, instance, capabilitiesNamesToUpdate);
1628 void testFillUpdatedInstRequirements() {
1629 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
1631 ComponentInstance instance = new ComponentInstance();
1632 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1633 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1634 RequirementDefinition requirementDefinition = new RequirementDefinition();
1635 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1636 requirementDefinitionList.add(requirementDefinition);
1637 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
1638 instance.setRequirements(requirements);
1639 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1640 requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
1641 "requirementsNamesToUpdate");
1642 Assertions.assertNotNull(instance);
1644 sIBL.fillUpdatedInstRequirements(updatedInstRequirements, instance, requirementsNamesToUpdate);
1648 void testAddRelationsToRI() {
1649 String yamlName = "group.yml";
1650 Service service = createServiceObject(true);
1652 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1653 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1654 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1655 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1656 ComponentInstance componentInstance = new ComponentInstance();
1657 componentInstance.setName("zxjTestImportServiceAb");
1658 componentInstancesList.add(componentInstance);
1659 service.setComponentInstances(componentInstancesList);
1660 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1661 RequirementDefinition requirementDefinition = new RequirementDefinition();
1662 requirementDefinition.setOwnerId("1");
1663 requirementDefinition.setUniqueId("2");
1664 requirementDefinition.setCapability("3");
1665 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1666 capabilityDefinition.setName("4");
1667 capabilityDefinition.setUniqueId("5");
1668 capabilityDefinition.setOwnerId("6");
1669 ResponseFormat responseFormat = new ResponseFormat();
1670 responseFormat.setStatus(200);
1671 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1672 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1673 anyString())).thenReturn(Either.left(requirementDefinition));
1674 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1675 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1676 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1677 Assertions.assertNotNull(service);
1679 sIBL.addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1683 void testAddRelationsToRI_null() {
1684 String yamlName = "group.yml";
1685 Service service = createServiceObject(true);
1686 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1687 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1688 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1689 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1690 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1692 Assertions.assertThrows(ComponentException.class, () -> sIBL.addRelationsToRI(yamlName,
1693 service, uploadResInstancesMap, componentInstancesList, relations));
1697 void testAddRelationToRI() {
1698 String yamlName = "group.yml";
1699 Service service = createServiceObject(true);
1700 service.setComponentInstances(creatComponentInstances());
1702 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1703 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1704 RequirementDefinition requirementDefinition = new RequirementDefinition();
1705 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1706 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1707 capabilityDefinition.setName("capabilityDefinitionName");
1708 capabilityDefinition.setUniqueId("capabilityDefinitionUniqueId");
1709 capabilityDefinition.setOwnerId("capabilityDefinitionOwnerId");
1710 ResponseFormat responseFormat = new ResponseFormat();
1711 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
1712 any(ComponentInstance.class), anyString())).thenReturn(Either.left(requirementDefinition));
1713 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1714 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1715 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1716 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1717 Assertions.assertNotNull(relations.get(0).getRelationships().get(0).getOperations());
1721 void testAddRelationToRI_null() {
1722 String yamlName = "group.yml";
1723 Service service = createServiceObject(true);
1724 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1725 service.setComponentInstances(componentInstancesList);
1726 ResponseFormat responseFormat = new ResponseFormat();
1727 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1728 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1729 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1730 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1734 void testGetResourceAfterCreateRelations() {
1735 Service service = createServiceObject(true);
1736 ComponentParametersView componentParametersView = createComponentParametersView();
1737 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1738 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1739 .thenReturn(Either.left(createServiceObject(true)));
1740 Assertions.assertNotNull(sIBL.getResourceAfterCreateRelations(service));
1744 void testCreateServiceInstances() {
1745 String yamlName = "group.yml";
1746 Service service = createServiceObject(true);
1747 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1748 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1749 uploadResInstancesMap.put("uploadResInstancesMap", nodesInfoValue);
1750 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1751 Resource resource = createParseResourceObject(true);
1752 resource.setToscaResourceName("toscaResourceName");
1753 nodeNamespaceMap.put("nodeNamespaceMap", resource);
1755 Assertions.assertThrows(ComponentException.class,
1756 () -> sIBL.createServiceInstances(yamlName, service, uploadResInstancesMap, nodeNamespaceMap));
1760 void testCreateAndAddResourceInstance() {
1761 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1762 String yamlName = "group.yml";
1763 Resource resource = createParseResourceObject(false);
1764 Resource originResource = createParseResourceObject(true);
1765 originResource.setResourceType(ResourceTypeEnum.VF);
1766 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1767 nodeNamespaceMap.put("resources", originResource);
1768 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1769 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1771 Assertions.assertThrows(ComponentException.class, () -> sIBL
1772 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, resource,
1773 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1777 void testCreateAndAddResourceInstances() {
1778 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1779 String yamlName = "group.yml";
1780 Service service = createServiceObject(true);
1781 service.setServiceType("services");
1782 Resource originResource = createParseResourceObject(true);
1783 originResource.setResourceType(ResourceTypeEnum.VF);
1784 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1785 nodeNamespaceMap.put("resources", originResource);
1786 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1787 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1789 Assertions.assertThrows(ComponentException.class, () -> sIBL
1790 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service,
1791 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1795 void testValidateResourceInstanceBeforeCreate() {
1796 String yamlName = "group.yml";
1797 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1798 Resource originResource = createParseResourceObject(true);
1799 ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
1800 componentMetadataDataDefinition.setState(LifecycleStateEnum.CERTIFIED.name());
1801 ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
1802 originResource.setComponentMetadataDefinition(componentMetadataDefinition);
1803 originResource.setComponentType(ComponentTypeEnum.RESOURCE);
1804 originResource.setToscaResourceName("toscaResourceName");
1805 originResource.setResourceType(ResourceTypeEnum.VF);
1806 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1807 nodeNamespaceMap.put("resources", originResource);
1808 when(toscaOperationFacade.getLatestByToscaResourceName(RESOURCE_TOSCA_NAME, null)).thenReturn(Either.left(originResource));
1809 Assertions.assertNotNull(
1810 sIBL.validateResourceInstanceBeforeCreate(yamlName, null, uploadComponentInstanceInfo, nodeNamespaceMap));
1814 void testHandleServiceNodeTypes() {
1815 String yamlName = "group.yml";
1816 Service service = createServiceObject(true);
1817 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1819 boolean needLock = true;
1820 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1821 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1822 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1823 CsarInfo csarInfo = getCsarInfo();
1824 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1825 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
1826 Assertions.assertNotNull(service);
1828 sIBL.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1829 nodeTypesNewCreatedArtifacts,
1830 nodeTypesInfo, csarInfo, nodeName);
1834 void testValidateResourceNotExisted() {
1835 String type = "org.openecomp.resource.vf";
1837 Assertions.assertThrows(ComponentException.class, () -> sIBL.validateResourceNotExisted(type));
1841 void testHandleNestedVF() {
1842 Service service = createServiceObject(true);
1843 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1844 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1845 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1846 CsarInfo csarInfo = getCsarInfo();
1847 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1849 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVF(service,
1850 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1854 void testHandleNestedVfc() {
1855 Service service = createServiceObject(true);
1856 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1857 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1858 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1859 CsarInfo csarInfo = getCsarInfo();
1860 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1862 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(service,
1863 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1867 void testHandleComplexVfc() {
1868 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1869 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1870 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1871 CsarInfo csarInfo = getCsarInfo();
1872 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1873 String yamlName = "group.yml";
1874 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1875 .thenReturn(createNewResource());
1876 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1877 .thenReturn(Either.left(createNewResource()));
1878 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class), anyBoolean()))
1879 .thenReturn(Either.left(true));
1881 Assertions.assertThrows(ComponentException.class, () -> sIBL
1882 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1883 csarInfo, nodeName, yamlName));
1887 void testHandleComplexVfcStatus() {
1888 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1889 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1890 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1891 CsarInfo csarInfo = getCsarInfo();
1892 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1893 String yamlName = "group.yml";
1894 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1895 .thenReturn(createNewResource());
1896 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1897 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1899 Assertions.assertThrows(ComponentException.class, () -> sIBL
1900 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1901 csarInfo, nodeName, yamlName));
1905 void testHandleComplexVfc2() {
1906 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1907 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1908 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1909 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1910 String yamlName = "group.yml";
1911 CsarInfo csarInfo = getCsarInfo();
1912 Map<String, byte[]> csar = new HashMap<>();
1913 csar.put(yamlName, yamlName.getBytes());
1914 csarInfo.setCsar(csar);
1915 Resource oldComplexVfc = createParseResourceObject(false);
1916 Resource newComplexVfc = createParseResourceObject(true);
1918 Assertions.assertThrows(ComponentException.class, () -> sIBL
1919 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1920 csarInfo, nodeName, yamlName, oldComplexVfc, newComplexVfc));
1924 void testUpdateResourceFromYaml() throws IOException {
1925 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1926 Resource newResource = createNewResource();
1927 Resource oldResource = createOldResource();
1928 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1929 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1930 String yamlFileName = "group.yml";
1931 String yamlFileContent = getYamlFileContent();
1932 CsarInfo csarInfo = getCsarInfo();
1933 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1934 Map<String, Object> map = new HashMap<>();
1935 map.put("tosca_definitions_version", "123");
1936 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1937 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1938 boolean isNested = true;
1940 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1941 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1942 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
1943 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
1944 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
1945 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
1946 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
1947 .thenReturn(Either.left(newResource));
1948 Assertions.assertThrows(ComponentException.class, () -> sIBL
1949 .updateResourceFromYaml(oldResource, newResource, actionEnum, createdArtifacts,
1950 yamlFileName, yamlFileContent, csarInfo, nodeTypesInfo,
1951 nodeTypesArtifactsToHandle, nodeName, isNested));
1955 void testCreateResourceFromYaml() throws IOException {
1956 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1957 Resource resource = createParseResourceObject(true);
1958 String topologyTemplateYaml = getMainTemplateContent();
1959 String yamlName = "group.yml";
1961 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1962 Map<String, Object> map = new HashMap<>();
1963 map.put("tosca_definitions_version", "123");
1964 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1966 CsarInfo csarInfo = getCsarInfo();
1967 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1968 boolean shouldLock = false;
1969 boolean inTransaction = true;
1971 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1972 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1973 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Component.class))).thenReturn(resource);
1974 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
1975 .thenReturn(Either.left(false));
1976 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
1977 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceFromYaml(resource,
1978 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
1979 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
1983 void testCreateResourceAndRIsFromYaml() throws IOException {
1984 String yamlName = "group.yml";
1985 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1986 Resource resource = createParseResourceObject(true);
1987 resource.setSystemName("SystemName");
1988 resource.setComponentType(ComponentTypeEnum.RESOURCE);
1989 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1990 boolean isNormative = true;
1991 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1992 String topologyTemplateYaml = getMainTemplateContent();
1993 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1994 Map<String, Object> map = new HashMap<>();
1995 map.put("tosca_definitions_version", "123");
1996 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1997 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1999 CsarInfo csarInfo = getCsarInfo();
2000 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
2001 boolean shouldLock = false;
2002 boolean inTransaction = true;
2003 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Resource.class)))
2004 .thenReturn(resource);
2006 when(serviceBusinessLogic.lockComponentByName(anyString(), any(), anyString()))
2007 .thenReturn(Either.left(true));
2009 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2010 .thenReturn(Either.left(false));
2012 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2014 Assertions.assertThrows(ComponentException.class, () -> sIBL
2015 .createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, actionEnum,
2016 isNormative, createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo,
2017 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
2021 void testCreateGroupsOnResource2() {
2022 Resource resource = createParseResourceObject(false);
2023 Map<String, GroupDefinition> groups = null;
2024 List<GroupDefinition> groupDefinitionList = new ArrayList<>();
2025 GroupDefinition groupDefinition = new GroupDefinition();
2026 groupDefinition.setUniqueId("groupDefinitionUniqueId");
2027 groupDefinition.setName("groupDefinition");
2028 groupDefinitionList.add(groupDefinition);
2030 Assertions.assertNotNull(
2031 sIBL.createGroupsOnResource(resource, groups));
2035 void testCreateGroupsOnResource2_null() {
2036 Resource resource = createParseResourceObject(false);
2037 Map<String, GroupDefinition> groups = null;
2039 Either<Resource, ResponseFormat> result = sIBL.createGroupsOnResource(resource, groups);
2040 assertEquals(result.left().value(), resource);
2044 void testUpdateGroupsMembersUsingResource2() {
2045 Resource resource = createParseResourceObject(true);
2046 Map<String, GroupDefinition> groups = getGroups();
2048 Assertions.assertNotNull(
2049 sIBL.updateGroupsMembersUsingResource(groups, resource));
2053 void testUpdateGroupsMembersUsingResource_left2() {
2054 Resource resource = createParseResourceObject(true);
2055 Map<String, GroupDefinition> groups = getGroups();
2057 Assertions.assertNotNull(
2058 sIBL.updateGroupsMembersUsingResource(groups, resource));
2062 void testUpdateGroupMembers() throws IOException {
2063 Map<String, GroupDefinition> groups = new HashMap<>();
2064 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2065 Resource component = createParseResourceObject(true);
2066 List<ComponentInstance> componentInstances = creatComponentInstances();
2067 String groupName = "tosca_simple_yaml_1_1";
2068 Map<String, String> members = new HashMap<>();
2069 members.put("zxjTestImportServiceAb", getGroupsYaml());
2070 Assertions.assertNotNull(component);
2072 sIBL.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2076 void testUpdateGroupMembers_null() throws IOException {
2077 Map<String, GroupDefinition> groups = new HashMap<>();
2078 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2079 Resource component = createParseResourceObject(true);
2080 List<ComponentInstance> componentInstances = new ArrayList<>();
2081 String groupName = "tosca_simple_yaml_1_1";
2082 Map<String, String> members = new HashMap<>();
2083 members.put("zxjTestImportServiceAb", getGroupsYaml());
2085 Assertions.assertThrows(ComponentException.class, () -> sIBL.updateGroupMembers(groups,
2086 updatedGroupDefinition, component, componentInstances, groupName, members));
2090 void setCreateResourceTransaction() {
2091 Resource resource = createParseResourceObject(false);
2092 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2093 boolean isNormative = true;
2094 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2095 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
2097 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2101 void setCreateResourceTransaction_leftTrue() {
2102 Resource resource = createParseResourceObject(false);
2103 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2104 boolean isNormative = true;
2105 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(true));
2107 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2111 void setCreateResourceTransaction_Left() {
2112 Resource resource = createParseResourceObject(false);
2113 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2114 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(false));
2115 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2116 Assertions.assertNotNull(sIBL.createResourceTransaction(resource, user, false));
2120 void testUpdateExistingResourceByImport() {
2121 Resource newResource = createNewResource();
2122 Resource oldResource = createOldResource();
2123 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
2124 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
2125 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
2126 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
2127 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
2128 .thenReturn(Either.left(newResource));
2129 Assertions.assertNotNull(sIBL.updateExistingResourceByImport(newResource, oldResource, user, true, false, true));
2133 void testCreateNewResourceToOldResource() {
2134 Resource newResource = createNewResource();
2135 Resource oldResource = createOldResource();
2137 sIBL.createNewResourceToOldResource(newResource, oldResource, user);
2138 assertEquals(newResource.getSystemName(), oldResource.getSystemName());
2142 void testCreateResourcesFromYamlNodeTypesList() {
2143 String yamlName = "group.yml";
2144 Service service = createServiceObject(true);
2145 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2146 boolean needLock = true;
2147 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2148 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2149 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2150 CsarInfo csarInfo = getCsarInfo();
2152 Assertions.assertThrows(ComponentException.class, () -> sIBL
2153 .createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock,
2154 nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo));
2158 void testCreateNodeTypes() {
2159 String yamlName = "group.yml";
2160 Service service = createServiceObject(true);
2161 boolean needLock = true;
2162 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2163 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2164 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2165 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2166 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2167 artifactDefinition.setArtifactName("artifactName");
2168 artifactDefinitions.add(artifactDefinition);
2169 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2170 artifactDefinitions);
2171 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2172 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2173 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2174 CsarInfo csarInfo = getCsarInfo();
2175 Map<String, Object> mapToConvert = new HashMap<>();
2176 Map<String, Object> nodeTypes = new HashMap<>();
2177 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2178 nodeTypesInfo.put("nodeTyp", nodeTypeInfo);
2179 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2182 Assertions.assertThrows(ComponentException.class, () -> sIBL.createNodeTypes(yamlName,
2183 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2184 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes));
2188 void testCreateNodeTypesElse() {
2189 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2190 String yamlName = "group.yml";
2191 Service service = createServiceObject(true);
2192 boolean needLock = true;
2193 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2194 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2195 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2196 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2197 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2198 artifactDefinition.setArtifactName("artifactName");
2199 artifactDefinitions.add(artifactDefinition);
2200 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2201 artifactDefinitions);
2202 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2203 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2204 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2205 Map<String, Object> map = new HashMap<>();
2206 map.put("tosca_definitions_version", "123");
2207 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
2208 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
2210 CsarInfo csarInfo = getCsarInfo();
2211 Map<String, Object> mapToConvert = new HashMap<>();
2212 Map<String, Object> nodeTypes = new HashMap<>();
2213 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2214 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2216 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class),
2217 anyMap(), any(Service.class), anyBoolean(), anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
2218 anyBoolean())).thenReturn(getResourceCreated());
2219 Assertions.assertNotNull(service);
2221 sIBL.createNodeTypes(yamlName,
2222 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2223 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
2226 protected ImmutablePair<Resource, ActionStatus> getResourceCreated() {
2227 Resource resource = createOldResource();
2228 ImmutablePair<Resource, ActionStatus> resourceCreated = new ImmutablePair<>(resource, ActionStatus.OK);
2230 return resourceCreated;
2233 protected Resource createNewResource() {
2234 Resource newResource = createParseResourceObject(false);
2235 newResource.setVersion("1.0");
2236 newResource.setInvariantUUID("");
2237 newResource.setLifecycleState(null);
2238 newResource.setUUID("");
2239 newResource.setNormalizedName("");
2240 newResource.setSystemName("");
2241 newResource.setCsarUUID("");
2242 newResource.setImportedToscaChecksum("");
2243 newResource.setDerivedFromGenericType("");
2244 newResource.setDerivedFromGenericVersion("");
2245 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2246 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2247 artifactDefinition.setArtifactName("artifactDefinition");
2248 toscaArtifacts.put("toscaArtifactsMap", artifactDefinition);
2249 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2250 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2251 interfaceDefinition.setOwnerId("OwnerId");
2252 interfaces.put("interfacesMap", interfaceDefinition);
2253 newResource.setInterfaces(interfaces);
2254 newResource.setToscaArtifacts(toscaArtifacts);
2255 newResource.setProperties(getProperties());
2259 protected Resource createOldResource() {
2260 Resource newResource = createParseResourceObject(false);
2261 newResource.setVersion("1.0");
2262 newResource.setUniqueId("ResourceUniqueId");
2263 newResource.setInvariantUUID("552e8f6c-340c-4fb4-8a82-fe7732fd8010");
2264 newResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
2265 newResource.setUUID("13065b80-ca96-4331-b643-d28aeaf961cb");
2266 newResource.setNormalizedName("NormalizedName");
2267 newResource.setSystemName("default");
2268 newResource.setCsarUUID("CsarUUID");
2269 newResource.setImportedToscaChecksum("ImportedToscaChecksum");
2270 newResource.setDerivedFromGenericType("DerivedFromGenericType");
2271 newResource.setDerivedFromGenericVersion("0.1");
2272 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2273 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2274 artifactDefinition.setArtifactName("tosca_simple_yaml_1_1");
2275 toscaArtifacts.put("tosca_definitions_version", artifactDefinition);
2276 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2277 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2278 interfaceDefinition.setDescription("Invoked upon receipt of an Instantiate VNF request");
2279 interfaces.put("tosca_simple_yaml_1_1", interfaceDefinition);
2280 newResource.setInterfaces(interfaces);
2281 newResource.setToscaArtifacts(toscaArtifacts);
2282 List<PropertyDefinition> properties = new ArrayList<>();
2283 PropertyDefinition propertyDefinition = new PropertyDefinition();
2284 propertyDefinition.setName("tosca_simple_yaml_1_1");
2285 properties.add(propertyDefinition);
2286 newResource.setProperties(properties);
2290 protected Map<String, InputDefinition> getCurrPropertiesMap() {
2291 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2292 InputDefinition inputDefinition = new InputDefinition();
2293 inputDefinition.setName("inputDefinitionName");
2294 inputDefinition.setUniqueId("uniqueId");
2295 inputDefinition.setType("inputDefinitionType");
2296 currPropertiesMap.put("propertyInfoName", inputDefinition);
2297 return currPropertiesMap;
2300 protected List<UploadPropInfo> getPropertyList() {
2301 List<UploadPropInfo> propertyList = new ArrayList<>();
2302 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2303 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2304 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2305 getInputValueDataDefinition.setInputName("inputDefinitionName");
2306 get_input.add(getInputValueDataDefinition);
2307 UploadPropInfo propertyInfo = new UploadPropInfo();
2308 propertyInfo.setValue("value");
2309 propertyInfo.setGet_input(get_input);
2310 propertyInfo.setName("propertyInfoName");
2311 propertyList.add(propertyInfo);
2312 return propertyList;
2315 private Map<String, NodeTypeInfo> getNodeTypesInfo() {
2316 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2317 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2318 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2319 nodeTypeInfo.setNested(true);
2320 nodeTypeInfo.setTemplateFileName("templateFileName");
2321 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2322 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2323 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2324 return nodeTypesInfo;
2327 private Map<String, Object> getNodeTypes() {
2328 Map<String, Object> nodeTypesInfo = new HashMap<>();
2329 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2330 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2331 nodeTypeInfo.setNested(true);
2332 nodeTypeInfo.setTemplateFileName("templateFileName");
2333 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2334 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2335 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2336 return nodeTypesInfo;
2339 private Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap() {
2340 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
2341 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2342 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
2343 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2344 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
2345 requirementsNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2346 uploadResInstancesMap.put("zxjTestImportServiceAb", uploadComponentInstanceInfo);
2347 return uploadResInstancesMap;
2350 protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties() {
2351 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
2352 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
2353 UploadPropInfo uploadPropInfo = new UploadPropInfo();
2354 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2355 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2356 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2357 get_input.add(getInputValueDataDefinition);
2358 uploadPropInfo.setName("propertiesName");
2359 uploadPropInfo.setValue("value");
2360 uploadPropInfo.setGet_input(get_input);
2361 uploadPropInfoList.add(uploadPropInfo);
2362 properties.put("uploadComponentInstanceInfo", uploadPropInfoList);
2366 protected List<PropertyDefinition> getProperties() {
2367 List<PropertyDefinition> properties = new ArrayList<>();
2368 PropertyDefinition propertyDefinition = new PropertyDefinition();
2369 propertyDefinition.setName("propertiesName");
2370 properties.add(propertyDefinition);
2374 protected Map<String, List<UploadReqInfo>> gerRequirements() {
2375 Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
2376 String requirementName = "tosca.capabilities.Node";
2377 List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
2378 UploadReqInfo uploadReqInfo = new UploadReqInfo();
2379 uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
2380 uploadReqInfoMap.put(requirementName, uploadReqInfoList);
2381 return uploadReqInfoMap;
2384 protected ComponentParametersView createComponentParametersView() {
2385 ComponentParametersView parametersView = new ComponentParametersView();
2386 parametersView.disableAll();
2387 parametersView.setIgnoreComponentInstances(false);
2388 parametersView.setIgnoreComponentInstancesProperties(false);
2389 parametersView.setIgnoreCapabilities(false);
2390 parametersView.setIgnoreRequirements(false);
2391 parametersView.setIgnoreGroups(false);
2392 return parametersView;
2395 protected Map<String, byte[]> crateCsarFromPayload() {
2396 String payloadName = "valid_vf.csar";
2397 String rootPath = System.getProperty("user.dir");
2401 Map<String, byte[]> returnValue = null;
2403 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2404 data = Files.readAllBytes(path);
2405 payloadData = Base64.encodeBase64String(data);
2406 UploadResourceInfo resourceInfo = new UploadResourceInfo();
2407 resourceInfo.setPayloadName(payloadName);
2408 resourceInfo.setPayloadData(payloadData);
2409 Method privateMethod = null;
2410 privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
2411 privateMethod.setAccessible(true);
2412 returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
2413 } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException |
2414 InvocationTargetException e) {
2415 e.printStackTrace();
2420 protected List<ComponentInstance> creatComponentInstances() {
2421 List<ComponentInstance> componentInstances = new ArrayList<>();
2422 ComponentInstance componentInstance = new ComponentInstance();
2423 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2424 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
2425 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
2426 capabilityDefinition.setName("mme_ipu_vdu.feature");
2427 capabilityDefinitionList.add(capabilityDefinition);
2428 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
2430 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2431 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2432 RequirementDefinition requirementDefinition = new RequirementDefinition();
2433 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
2434 requirementDefinitionList.add(requirementDefinition);
2435 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
2436 componentInstance.setRequirements(requirements);
2437 componentInstance.setCapabilities(capabilities);
2438 componentInstance.setUniqueId("uniqueId");
2439 componentInstance.setComponentUid("componentUid");
2440 componentInstance.setName("zxjTestImportServiceAb");
2441 componentInstance.setNormalizedName("zxjTestImportServiceAb");
2442 componentInstance.setProperties(getProperties());
2443 componentInstances.add(componentInstance);
2444 return componentInstances;
2447 private CreateServiceFromYamlParameter getCsfyp() {
2448 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
2449 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2450 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2452 csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
2453 csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
2454 csfyp.setCreatedArtifacts(createdArtifacts);
2455 csfyp.setInTransaction(true);
2456 csfyp.setShouldLock(true);
2457 csfyp.setCsarInfo(getCsarInfo());
2458 csfyp.setParsedToscaYamlInfo(getParsedToscaYamlInfo());
2459 csfyp.setNodeTypesInfo(nodeTypesInfo);
2460 csfyp.setYamlName("group.yml");
2464 private ParsedToscaYamlInfo getParsedToscaYamlInfo() {
2465 ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
2466 Map<String, InputDefinition> inputs = new HashMap<>();
2467 Map<String, UploadComponentInstanceInfo> instances = new HashMap<>();
2468 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2469 instances.put("instances", uploadComponentInstanceInfo);
2470 Map<String, GroupDefinition> groups = new HashMap<>();
2471 Map<String, PolicyDefinition> policies = new HashMap<>();
2472 parsedToscaYamlInfo.setGroups(groups);
2473 parsedToscaYamlInfo.setInputs(inputs);
2474 parsedToscaYamlInfo.setInstances(instances);
2475 parsedToscaYamlInfo.setPolicies(policies);
2476 return parsedToscaYamlInfo;
2479 String getMainTemplateContent(String fileName) {
2480 String mainTemplateContent = null;
2482 mainTemplateContent = loadFileNameToJsonString(fileName);
2483 } catch (IOException e) {
2484 e.printStackTrace();
2486 return mainTemplateContent;
2489 protected ServiceCsarInfo getCsarInfo() {
2490 String csarUuid = "0010";
2491 User user = new User("jh0003");
2494 File csarFile = new File(
2495 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
2496 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
2498 String vfReousrceName = "resouceName";
2499 String mainTemplateName = "Definitions/service_import_template.yml";
2501 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
2502 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
2503 assertNotNull(mainTemplateService);
2504 final String mainTemplateContent = new String(mainTemplateService);
2506 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false, mock(ModelOperation.class));
2507 } catch (URISyntaxException | ZipException e) {
2513 private ImmutablePair<String, byte[]> getNodeType() {
2515 File resource = new File(
2516 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("node-types/resource-Extcp-template.yml").toURI());
2517 byte[] extcpResource = Files.readAllBytes(resource.toPath());
2519 return new ImmutablePair<>("org.openecomp.resource.cp.extCP", extcpResource);
2520 } catch (URISyntaxException | IOException e) {
2526 protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo() {
2527 String artifactName = "artifactName", path = "/src/test/resources/valid_vf.csar", artifactType = "AAI_SERVICE_MODEL";
2528 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
2529 String rootPath = System.getProperty("user.dir");
2531 byte[] data = new byte[0];
2532 path2 = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2534 data = Files.readAllBytes(path2);
2535 } catch (IOException e) {
2536 e.printStackTrace();
2538 String artifactUniqueId = "artifactUniqueId";
2539 boolean isFromCsar = true;
2540 CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
2541 path, artifactType, artifactGroupType, data, artifactUniqueId, isFromCsar);
2542 return nonMetaArtifactInfo;
2546 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2547 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2548 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2549 assertParseResponse(actualResponse, expectedStatus, variables);
2552 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2553 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2554 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2555 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());