2 * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.openecomp.sdc.be.components.impl;
19 import static org.assertj.core.api.Java6Assertions.assertThat;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertNotNull;
22 import static org.junit.jupiter.api.Assertions.fail;
23 import static org.mockito.ArgumentMatchers.anyString;
24 import static org.mockito.Mockito.any;
25 import static org.mockito.Mockito.anyBoolean;
26 import static org.mockito.Mockito.anyList;
27 import static org.mockito.Mockito.anyMap;
28 import static org.mockito.Mockito.contains;
29 import static org.mockito.Mockito.doNothing;
30 import static org.mockito.Mockito.doReturn;
31 import static org.mockito.Mockito.eq;
32 import static org.mockito.Mockito.isNull;
33 import static org.mockito.Mockito.matches;
34 import static org.mockito.Mockito.mock;
35 import static org.mockito.Mockito.verify;
36 import static org.mockito.Mockito.when;
37 import static org.openecomp.sdc.be.components.impl.ServiceImportBusinessLogic.CREATE_RESOURCE;
39 import fj.data.Either;
41 import java.io.IOException;
42 import java.lang.reflect.InvocationTargetException;
43 import java.lang.reflect.Method;
44 import java.net.URISyntaxException;
45 import java.nio.file.FileSystems;
46 import java.nio.file.Files;
47 import java.nio.file.Path;
48 import java.nio.file.Paths;
49 import java.util.ArrayList;
50 import java.util.Collections;
51 import java.util.EnumMap;
52 import java.util.HashMap;
53 import java.util.List;
55 import java.util.Optional;
57 import org.apache.commons.codec.binary.Base64;
58 import org.apache.commons.collections.map.HashedMap;
59 import org.apache.commons.lang3.tuple.ImmutablePair;
60 import org.json.simple.JSONObject;
61 import org.junit.jupiter.api.Assertions;
62 import org.junit.jupiter.api.BeforeEach;
63 import org.junit.jupiter.api.Test;
64 import org.mockito.ArgumentCaptor;
65 import org.mockito.InjectMocks;
66 import org.mockito.MockitoAnnotations;
67 import org.openecomp.sdc.be.components.csar.CsarInfo;
68 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
69 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
70 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
71 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
72 import org.openecomp.sdc.be.dao.api.ActionStatus;
73 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
74 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
76 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
77 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
79 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
80 import org.openecomp.sdc.be.externalapi.servlet.ArtifactExternalServlet;
81 import org.openecomp.sdc.be.impl.ServletUtils;
82 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
83 import org.openecomp.sdc.be.model.ArtifactDefinition;
84 import org.openecomp.sdc.be.model.AttributeDefinition;
85 import org.openecomp.sdc.be.model.CapabilityDefinition;
86 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
87 import org.openecomp.sdc.be.model.Component;
88 import org.openecomp.sdc.be.model.ComponentInstance;
89 import org.openecomp.sdc.be.model.ComponentInstanceInput;
90 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
91 import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
92 import org.openecomp.sdc.be.model.ComponentParametersView;
93 import org.openecomp.sdc.be.model.DataTypeDefinition;
94 import org.openecomp.sdc.be.model.GroupDefinition;
95 import org.openecomp.sdc.be.model.GroupTypeDefinition;
96 import org.openecomp.sdc.be.model.IPropertyInputCommon;
97 import org.openecomp.sdc.be.model.InputDefinition;
98 import org.openecomp.sdc.be.model.InterfaceDefinition;
99 import org.openecomp.sdc.be.model.LifecycleStateEnum;
100 import org.openecomp.sdc.be.model.NodeTypeInfo;
101 import org.openecomp.sdc.be.model.Operation;
102 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
103 import org.openecomp.sdc.be.model.PolicyDefinition;
104 import org.openecomp.sdc.be.model.PropertyDefinition;
105 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
106 import org.openecomp.sdc.be.model.RequirementDefinition;
107 import org.openecomp.sdc.be.model.Resource;
108 import org.openecomp.sdc.be.model.Service;
109 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
110 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
111 import org.openecomp.sdc.be.model.UploadPropInfo;
112 import org.openecomp.sdc.be.model.UploadReqInfo;
113 import org.openecomp.sdc.be.model.UploadResourceInfo;
114 import org.openecomp.sdc.be.model.User;
115 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
116 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
117 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
118 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
119 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
120 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
121 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
122 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
123 import org.openecomp.sdc.be.servlets.AbstractValidationsServlet;
124 import org.openecomp.sdc.be.tosca.CsarUtils;
125 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
126 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
127 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
128 import org.openecomp.sdc.common.api.Constants;
129 import org.openecomp.sdc.common.zip.ZipUtils;
130 import org.openecomp.sdc.common.zip.exception.ZipException;
131 import org.openecomp.sdc.exception.ResponseFormat;
132 import org.yaml.snakeyaml.Yaml;
134 class ServiceImportBusinessLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
136 private final ArtifactDefinition artifactDefinition = mock(ArtifactDefinition.class);
137 private final ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
138 private final ServletUtils servletUtils = mock(ServletUtils.class);
139 private final AbstractValidationsServlet servlet = new ArtifactExternalServlet(
140 componentInstanceBusinessLogic, componentsUtils, servletUtils, resourceImportManager, artifactsBusinessLogic);
141 private final ApplicationDataTypeCache applicationDataTypeCache = mock(ApplicationDataTypeCache.class);
142 private final ArtifactTypeOperation artifactTypeOperation = mock(ArtifactTypeOperation.class);
143 private final DataTypeBusinessLogic dataTypeBusinessLogic = mock(DataTypeBusinessLogic.class);
144 private final ArtifactTypeImportManager artifactTypeImportManager = mock(ArtifactTypeImportManager.class);
145 private final GroupTypeOperation groupTypeOperation = mock(GroupTypeOperation.class);
146 private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
147 private final CapabilityTypeImportManager capabilityTypeImportManager = mock(CapabilityTypeImportManager.class);
148 private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager = mock(InterfaceLifecycleTypeImportManager.class);
151 private ServiceImportBusinessLogic sIBL;
153 public static String loadFileNameToJsonString(String fileName) throws IOException {
154 String sourceDir = "src/test/resources/normativeTypes";
155 return loadFileNameToJsonString(sourceDir, fileName);
158 private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
159 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
160 byte[] fileContent = Files.readAllBytes(filePath);
161 return new String(fileContent);
166 MockitoAnnotations.openMocks(this);
167 when(artifactDefinition.getMandatory()).thenReturn(true);
168 when(artifactDefinition.getArtifactName()).thenReturn("creatorFullName");
169 when(artifactDefinition.getArtifactType()).thenReturn("TOSCA_CSAR");
173 void testCreateService_OK() {
174 Service oldService = createServiceObject(true);
175 oldService.setComponentInstances(creatComponentInstances());
176 oldService.setComponentInstancesProperties(
177 Collections.singletonMap(COMPONENT_ID, Collections.singletonList(new ComponentInstanceProperty())));
178 String payloadName = "valid_vf";
179 Map<String, byte[]> payload = crateCsarFromPayload();
180 Service newService = createServiceObject(true);
181 newService.setComponentInstances(creatComponentInstances());
182 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
183 componentInstanceProperty.setName("propertiesName");
184 final JSONObject jsonObject = new JSONObject();
185 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), "zxjTestImportServiceAb_propertiesName");
186 componentInstanceProperty.setValue(jsonObject.toJSONString());
188 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
189 ArtifactDefinition artifactDef = new ArtifactDefinition();
190 String artifactUniqueId = "test_extcp_resource.assettoscatemplate";
191 artifactDef.setUniqueId(artifactUniqueId);
192 toscaArtifacts.put(ToscaExportHandler.ASSET_TOSCA_TEMPLATE, artifactDef);
193 Resource resource = new Resource();
194 String resourceUniqueId = "extcp_resource";
195 resource.setUniqueId(resourceUniqueId);
196 resource.setToscaArtifacts(toscaArtifacts);
197 resource.getComponentMetadataDefinition().getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
198 resource.setResourceType(ResourceTypeEnum.VF);
200 ImmutablePair<String, byte[]> resourceTemplate = getNodeType();
201 String updatedNodeType = "org.openecomp.resource.cp.extCP";
202 resource.setToscaResourceName(updatedNodeType);
204 newService.setComponentInstancesProperties(
205 Collections.singletonMap(COMPONENT_ID + "." + "zxjTestImportServiceAb", Collections.singletonList(componentInstanceProperty)));
206 newService.setProperties(getProperties());
208 when(serviceBusinessLogic.validateServiceBeforeCreate(eq(newService), any(User.class), any(AuditingActionEnum.class)))
209 .thenReturn(Either.left(newService));
210 when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
211 ServiceCsarInfo csarInfo = getCsarInfo();
212 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(csarInfo);
213 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
214 .thenReturn(Either.left(new HashMap<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>>()));
215 doReturn(getParsedToscaYamlInfo()).when(csarBusinessLogic).getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), any(), any(Service.class));
216 // 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, AuditingActionEnum.CREATE_RESOURCE)).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(), any())).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(), any())).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, null));
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(), null));
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(), null));
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(), null));
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<>();
682 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(createServiceObject(true)));
683 when(csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
684 anyString(), anyString(), anyList(), anyBoolean(), anyBoolean())).thenReturn(Either.left(preparedService));
685 Assertions.assertNotNull(
686 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
687 preparedService, true, true));
691 void testHandleVfCsarServiceArtifacts() {
692 Service service = createServiceObject(true);
693 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
694 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
695 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
696 artifactDefinition.setUniqueId("uniqueId");
697 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
698 service.setDeploymentArtifacts(deploymentArtifacts);
699 CsarInfo csarInfo = getCsarInfo();
700 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
701 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
702 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
703 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean())).thenReturn(
704 Either.left(service));
705 Assertions.assertNotNull(
706 sIBL.handleVfCsarArtifacts(service, csarInfo, createdArtifacts, artifactOperation, true, true));
710 void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
711 Service service = createServiceObject(true);
712 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
713 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
714 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
715 artifactDefinition.setUniqueId("uniqueId");
716 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
717 service.setDeploymentArtifacts(deploymentArtifacts);
718 CsarInfo csarInfo = getCsarInfo();
719 Map<String, byte[]> csar = new HashMap<>();
720 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
721 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
722 csar.put(csarKey, artifactsMetaBytes);
723 csarInfo.setCsar(csar);
724 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
725 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
726 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
727 when(csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
728 anyString(), anyString(), anyList())).thenReturn(Either.left(service));
729 Assertions.assertNotNull(
730 sIBL.handleVfCsarArtifacts(service,
731 csarInfo, createdArtifacts, artifactOperation, true, true));
735 void testCreateOrUpdateNonMetaServiceArtifacts() {
736 CsarInfo csarInfo = getCsarInfo();
737 Service service = createServiceObject(true);
738 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
739 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
741 Either<Service, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo,
742 service, createdArtifacts, true, true, artifactOperation);
743 assertEquals(result.left().value(), service);
747 void testFindServiceCsarArtifactsToHandle() {
748 Service service = createServiceObject(true);
749 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
750 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
751 artifactDefinition.setArtifactName("artifactDefinition");
752 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
753 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
754 artifacts.put("artifacts", artifactDefinition);
755 List<GroupDefinition> groups = new ArrayList<>();
756 GroupDefinition groupDefinition = new GroupDefinition();
757 groupDefinition.setUniqueId("groupDefinitionUniqueId");
758 groupDefinition.setName("groupDefinition");
759 groups.add(groupDefinition);
760 service.setDeploymentArtifacts(deploymentArtifacts);
761 service.setArtifacts(artifacts);
762 service.setGroups(groups);
763 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
765 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
766 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
767 assertNotNull(result.left().value());
771 void testOrganizeVfCsarArtifactsByServiceArtifactOperation() {
772 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
773 artifactPathAndNameList.add(getNonMetaArtifactInfo());
774 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
775 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
776 artifactDefinition.setArtifactName("artifactName");
777 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
778 artifactDefinition.setArtifactChecksum("artifactChecksum");
779 existingArtifactsToHandle.add(artifactDefinition);
780 Service service = createServiceObject(true);
782 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
783 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
784 existingArtifactsToHandle, service, user);
785 assertNotNull(enumMapResponseFormatEither.left().value());
789 void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse() {
790 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
791 artifactPathAndNameList.add(getNonMetaArtifactInfo());
792 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
793 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
794 artifactDefinition.setArtifactName("artifactName");
795 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
796 artifactDefinition.setArtifactChecksum("artifactChecksum");
797 existingArtifactsToHandle.add(artifactDefinition);
798 Service service = createServiceObject(true);
799 Assertions.assertNotNull(
800 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user));
805 void testProcessServiceCsarArtifacts() {
806 CsarInfo csarInfo = getCsarInfo();
807 Service service = createServiceObject(true);
808 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
809 Either<Service, ResponseFormat> resStatus = Either.left(service);
810 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
811 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
812 List<CsarUtils.NonMetaArtifactInfo> objects = new ArrayList<>();
813 objects.add(getNonMetaArtifactInfo());
814 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, objects);
815 Assertions.assertNotNull(
816 sIBL.processCsarArtifacts(csarInfo, service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
820 void testGetValidArtifactNames() {
821 CsarInfo csarInfo = getCsarInfo();
822 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
823 Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIBL.getValidArtifactNames(csarInfo,
824 collectedWarningMessages);
825 assertNotNull(result.left().value());
829 void testCreateOrUpdateSingleNonMetaServiceArtifact() {
830 Service service = createServiceObject(true);
831 CsarInfo csarInfo = getCsarInfo();
832 Map<String, byte[]> csar = csarInfo.getCsar();
833 String rootPath = System.getProperty("user.dir");
835 byte[] data = new byte[0];
836 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
838 data = Files.readAllBytes(path);
839 } catch (IOException e) {
842 csar.put("valid_vf.csar", data);
843 csarInfo.setCsar(csar);
844 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
845 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
846 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
847 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
848 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
849 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
850 artifactDefinition.setArtifactName("artifactName");
851 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
852 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Service.class), any(User.class),
853 anyMap(), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
854 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
855 .thenReturn(Either.left(artifactDefinition));
856 Assertions.assertNotNull(
857 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
858 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
859 artifactDescription, artifactId, artifactOperation, createdArtifacts,
864 void testCreateOrUpdateSingleNonMetaServiceArtifactNull() {
865 Service service = createServiceObject(true);
866 CsarInfo csarInfo = getCsarInfo();
867 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
868 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
869 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
870 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
871 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
872 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
873 .thenReturn(Either.left(artifactDefinition));
874 Assertions.assertNotNull(
875 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
876 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
877 artifactDescription, artifactId, artifactOperation, createdArtifacts,
882 void testCreateGroupsOnResource() {
883 Service service = createServiceObject(true);
884 Map<String, GroupDefinition> groups = new HashMap<>();
885 Assertions.assertNotNull(sIBL.createGroupsOnResource(service, groups));
889 void testCreateGroupsOnResourceNull() {
890 Service service = createServiceObject(true);
891 Map<String, GroupDefinition> groups = new HashMap<>();
892 Assertions.assertNotNull(
893 sIBL.createGroupsOnResource(service, groups));
897 void testUpdateGroupsMembersUsingResource() {
898 Service service = createServiceObject(true);
899 Map<String, GroupDefinition> groups = getGroups();
901 Assertions.assertNotNull(
902 sIBL.updateGroupsMembersUsingResource(groups, service));
906 void testUpdateGroupsMembersUsingResource_left() {
907 Service service = createServiceObject(true);
908 Map<String, GroupDefinition> groups = getGroups();
910 Assertions.assertNotNull(
911 sIBL.updateGroupsMembersUsingResource(groups, service));
915 void testCreateRIAndRelationsFromResourceYaml() throws IOException {
916 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
917 String yamlName = "group.yml";
918 Resource resource = createParseResourceObject(true);
919 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
920 String topologyTemplateYaml = getMainTemplateContent();
921 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
923 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
924 Map<String, Object> map = new HashMap<>();
925 map.put("tosca_definitions_version", "123");
926 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
928 CsarInfo csarInfo = getCsarInfo();
929 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
931 Assertions.assertThrows(ComponentException.class, () -> sIBL
932 .createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
933 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
934 csarInfo, nodeTypesArtifactsToCreate, nodeName));
938 void testCreateResourceInstancesRelations() {
939 String yamlName = "group.yml";
940 Resource resource = createParseResourceObject(true);
941 resource.setComponentInstances(creatComponentInstances());
942 resource.setResourceType(ResourceTypeEnum.VF);
943 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
944 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
945 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
946 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
947 Assertions.assertThrows(ComponentException.class, () -> sIBL
948 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
952 void testCreateResourceInstancesRelations_Empty() {
953 String yamlName = "group.yml";
954 Resource resource = createParseResourceObject(true);
955 resource.setComponentInstances(creatComponentInstances());
956 resource.setResourceType(ResourceTypeEnum.VF);
957 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
958 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
959 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
960 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
961 Assertions.assertThrows(ComponentException.class, () -> sIBL
962 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
966 void testProcessComponentInstance1() {
967 String yamlName = "group.yml";
968 Resource resource = createParseResourceObject(true);
969 Resource originResource = createParseResourceObject(false);
970 originResource.setResourceType(ResourceTypeEnum.VF);
971 List<ComponentInstance> componentInstancesList = creatComponentInstances();
972 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
973 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
974 dataTypeDefinition.setName("dataTypeDefinitionName");
975 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
976 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
977 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
978 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
979 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
980 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
981 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
982 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
983 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
984 Map<String, Resource> originCompMap = new HashMap<>();
985 originCompMap.put("componentUid", originResource);
986 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
987 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
988 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
989 Assertions.assertNotNull(resource);
990 Assertions.assertNotNull(yamlName);
991 sIBL.processComponentInstance(yamlName, resource, componentInstancesList, allDataTypes.left().value(), instProperties,
992 instCapabilties, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes,
993 originCompMap, instInputs, instNodeFilter, null, uploadComponentInstanceInfo);
997 void testProcessComponentInstance_null() {
998 String yamlName = "group.yml";
999 Resource resource = createParseResourceObject(true);
1000 Resource originResource = createParseResourceObject(false);
1001 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1002 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1003 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1004 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1005 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1006 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1007 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1008 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1009 Map<String, Resource> originCompMap = new HashMap<>();
1010 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1011 originCompMap.put("componentUid", originResource);
1012 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1013 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1014 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1016 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1017 resource, componentInstancesList, null, instProperties, instCapabilties,
1018 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1019 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1023 void testAddInputsValuesToRi() {
1024 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1025 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1026 List<UploadPropInfo> uploadPropInfoList = getPropertyList();
1027 properties.put("propertiesMap", uploadPropInfoList);
1028 uploadComponentInstanceInfo.setProperties(properties);
1029 Resource resource = createParseResourceObject(true);
1030 Resource originResource = createParseResourceObject(false);
1031 List<InputDefinition> inputs = new ArrayList<>();
1032 InputDefinition inputDefinition = new InputDefinition();
1033 inputDefinition.setName("inputDefinitionName");
1034 inputDefinition.setUniqueId("uniqueId");
1035 inputDefinition.setType("inputDefinitionType");
1036 inputs.add(inputDefinition);
1037 originResource.setInputs(inputs);
1038 ComponentInstance currentCompInstance = new ComponentInstance();
1039 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1040 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1041 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1042 dataTypeDefinition.setName("dataTypeDefinitionName");
1043 allDataTypes.put("dataTypeDefinitionMap", dataTypeDefinition);
1045 Assertions.assertThrows(ComponentException.class, () -> sIBL
1046 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1047 currentCompInstance, instInputs, allDataTypes));
1051 void testProcessProperty() {
1052 Resource resource = createParseResourceObject(true);
1053 List<InputDefinition> inputs = new ArrayList<>();
1054 InputDefinition inputDefinition = new InputDefinition();
1055 inputDefinition.setName("inputDefinitionName");
1056 inputDefinition.setUniqueId("uniqueId");
1057 inputDefinition.setType("inputDefinitionType");
1058 inputs.add(inputDefinition);
1059 resource.setInputs(inputs);
1060 ComponentInstance currentCompInstance = null;
1061 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1062 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1063 currPropertiesMap.put("propertyInfoName", inputDefinition);
1064 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1065 List<UploadPropInfo> propertyList = getPropertyList();
1066 Assertions.assertNotNull(resource);
1067 Assertions.assertNotNull(currPropertiesMap);
1068 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1072 void testHandleSubstitutionMappings() {
1073 Resource resource = createParseResourceObject(true);
1074 resource.setResourceType(ResourceTypeEnum.VF);
1075 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1076 when(toscaOperationFacade.getToscaFullElement(anyString()))
1077 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1079 Assertions.assertThrows(ComponentException.class,
1080 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1084 void testHandleSubstitutionMappings_left() {
1085 Resource resource = createParseResourceObject(true);
1086 resource.setResourceType(ResourceTypeEnum.VF);
1087 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1088 when(toscaOperationFacade.getToscaFullElement(anyString()))
1089 .thenReturn(Either.left(resource));
1091 Assertions.assertThrows(ComponentException.class,
1092 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1096 void testCreateResourceInstances() {
1097 String yamlName = "group.yml";
1098 Resource resource = createParseResourceObject(true);
1099 Resource originResource = createParseResourceObject(false);
1100 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1101 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
1102 nodesInfoValue.setName("zxjTestImportServiceAb");
1103 nodesInfoValue.setRequirements(gerRequirements());
1104 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1105 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1106 nodeNamespaceMap.put("resources", originResource);
1108 Assertions.assertThrows(ComponentException.class,
1109 () -> sIBL.createResourceInstances(yamlName, resource, uploadResInstancesMap, nodeNamespaceMap));
1113 void testHandleNodeTypes() throws IOException {
1114 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1115 String yamlName = "group.yml";
1116 Resource resource = createParseResourceObject(true);
1117 String topologyTemplateYaml = getMainTemplateContent();
1118 boolean needLock = true;
1119 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1120 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1121 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1122 Map<String, Object> map = new HashMap<>();
1123 map.put("tosca_definitions_version", "123");
1124 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1125 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1126 CsarInfo csarInfo = getCsarInfo();
1127 Assertions.assertNotNull(resource);
1129 sIBL.handleNodeTypes(yamlName, resource, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1130 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
1134 void testHandleNestedVfc1() {
1135 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1136 Resource resource = createParseResourceObject(false);
1137 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1138 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1139 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1140 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1141 nodeTypeInfo.setTemplateFileName("groups.yml");
1142 nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
1143 nodesInfo.put(nodeName, nodeTypeInfo);
1144 CsarInfo csarInfo = getCsarInfo();
1146 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(resource,
1147 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1151 void testHandleComplexVfc1() {
1152 Resource resource = createParseResourceObject(true);
1153 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1154 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1155 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1156 CsarInfo csarInfo = getCsarInfo();
1157 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1158 String yamlName = "group.yml";
1159 when(serviceImportParseLogic.buildValidComplexVfc(any(Resource.class), any(CsarInfo.class), anyString(),
1160 anyMap())).thenReturn(createParseResourceObject(false));
1161 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1162 .thenReturn(Either.left(resource));
1163 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class),
1164 anyBoolean())).thenReturn(Either.left(true));
1166 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleComplexVfc(resource,
1167 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName));
1171 void testCreateNodeTypes1() {
1172 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1173 String yamlName = "group.yml";
1174 Resource resource = createParseResourceObject(false);
1175 boolean needLock = true;
1176 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1177 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
1178 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1179 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
1180 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1181 artifactDefinition.setArtifactName("artifactName");
1182 artifactDefinitions.add(artifactDefinition);
1183 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
1184 artifactDefinitions);
1185 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
1186 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1187 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1188 Map<String, Object> map = new HashMap<>();
1189 map.put("tosca_definitions_version", "123");
1190 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1191 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1193 CsarInfo csarInfo = getCsarInfo();
1194 Map<String, Object> mapToConvert = new HashMap<>();
1195 Map<String, Object> nodeTypes = new HashMap<>();
1196 nodeTypes.put(nodeName, "");
1197 Assertions.assertNotNull(resource);
1199 sIBL.createNodeTypes(yamlName,
1200 resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1201 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
1205 void testCreateNodeTypeResourceFromYaml() throws IOException {
1206 String yamlName = "group.yml";
1207 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1208 Map<String, Object> nodeMap = new HashMap<>();
1209 nodeMap.put(nodeName, getGroupsYaml());
1210 Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
1211 Map<String, Object> mapToConvert = new HashedMap();
1212 Resource resourceVf = createParseResourceObject(false);
1213 boolean needLock = true;
1214 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
1215 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1216 boolean forceCertificationAllowed = true;
1217 CsarInfo csarInfo = getCsarInfo();
1218 boolean isNested = true;
1219 UploadResourceInfo resourceMetaData = new UploadResourceInfo();
1220 resourceMetaData.setResourceType("VFC");
1221 ImmutablePair<Resource, ActionStatus> immutablePair = new ImmutablePair<>(resourceVf, ActionStatus.CREATED);
1222 when(serviceImportParseLogic.fillResourceMetadata(anyString(), any(Resource.class), anyString(), any(User.class)))
1223 .thenReturn(resourceMetaData);
1224 when(serviceImportParseLogic.buildNodeTypeYaml(any(Map.Entry.class), anyMap(), anyString(), any(CsarInfo.class)))
1225 .thenReturn(nodeName);
1226 when(serviceBusinessLogic.validateUser(any(User.class), anyString(), any(Component.class), any(AuditingActionEnum.class),
1227 anyBoolean())).thenReturn(user);
1228 when(serviceImportParseLogic.createResourceFromNodeType(anyString(), any(UploadResourceInfo.class), any(User.class), anyBoolean(),
1230 anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
1231 anyString(), anyBoolean())).thenReturn(immutablePair);
1232 Assertions.assertNotNull(
1233 sIBL.createNodeTypeResourceFromYaml(yamlName, nodeNameValue, user, mapToConvert,
1234 resourceVf, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1235 forceCertificationAllowed, csarInfo, isNested));
1239 void testCreateRIAndRelationsFromYaml() {
1240 String yamlName = "group.yml";
1241 Service service = createServiceObject(true);
1242 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
1243 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1245 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1246 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1247 CsarInfo csarInfo = getCsarInfo();
1248 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1249 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1251 Assertions.assertNotNull(sIBL
1252 .createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap,
1253 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1254 csarInfo, nodeTypesArtifactsToCreate, nodeName));
1258 void testCreateServiceInstancesRelations() {
1259 String yamlName = "group.yml";
1260 Service service = createServiceObject(true);
1261 service.setComponentInstances(creatComponentInstances());
1262 Resource newResource = createNewResource();
1263 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1264 ComponentParametersView componentParametersView = new ComponentParametersView();
1265 RequirementDefinition requirementDefinition = new RequirementDefinition();
1266 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1267 capabilityDefinition.setName("as");
1268 capabilityDefinition.setUniqueId("1");
1269 capabilityDefinition.setOwnerId("2");
1270 ResponseFormat responseFormat = new ResponseFormat();
1271 responseFormat.setStatus(200);
1272 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(newResource);
1273 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1274 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(service));
1275 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1276 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1277 anyString())).thenReturn(Either.left(requirementDefinition));
1278 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1279 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1280 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1281 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
1282 Assertions.assertNotNull(sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
1286 void testCreateServiceInstancesRelations_Empty() {
1287 String yamlName = "group.yml";
1288 Service service = createServiceObject(true);
1289 service.setComponentInstances(creatComponentInstances());
1290 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1292 Assertions.assertThrows(ComponentException.class,
1293 () -> sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
1297 void testProcessComponentInstance() {
1298 String yamlName = "group.yml";
1299 Service service = createServiceObject(true);
1300 Resource originResource = createParseResourceObject(false);
1301 originResource.setResourceType(ResourceTypeEnum.VF);
1302 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1303 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
1304 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1305 dataTypeDefinition.setName("dataTypeDefinitionName");
1306 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
1307 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
1308 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1309 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1310 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1311 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1312 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1313 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1314 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1315 Map<String, Resource> originCompMap = new HashMap<>();
1316 originCompMap.put("componentUid", originResource);
1317 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1318 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1319 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
1320 Assertions.assertNotNull(service);
1322 sIBL.processComponentInstance(yamlName, service, componentInstancesList, allDataTypes.left().value(),
1323 instProperties, instCapabilties, instRequirements, instDeploymentArtifacts,
1324 instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, null,
1325 uploadComponentInstanceInfo);
1329 void testProcessComponentInstance_null2() {
1330 String yamlName = "group.yml";
1331 Service service = createServiceObject(true);
1332 Resource originResource = createParseResourceObject(false);
1333 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1334 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1335 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1336 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1337 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1338 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1339 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1340 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1341 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1342 Map<String, Resource> originCompMap = new HashMap<>();
1343 originCompMap.put("componentUid", originResource);
1344 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1345 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1346 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1348 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1349 service, componentInstancesList, null, instProperties, instCapabilties,
1350 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1351 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1355 void testAddInputsValuesToRi2() {
1356 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1357 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1358 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
1359 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1360 uploadPropInfo.setName("uploadPropInfo");
1361 uploadPropInfoList.add(uploadPropInfo);
1362 uploadPropInfoList.add(uploadPropInfo);
1363 properties.put("propertiesMap", uploadPropInfoList);
1364 uploadComponentInstanceInfo.setProperties(properties);
1365 Service resource = createServiceObject(true);
1366 Resource originResource = createParseResourceObject(false);
1367 List<InputDefinition> inputs = new ArrayList<>();
1368 InputDefinition inputDefinition = new InputDefinition();
1369 inputDefinition.setUniqueId("uniqueId");
1370 inputs.add(inputDefinition);
1371 originResource.setInputs(inputs);
1372 ComponentInstance currentCompInstance = new ComponentInstance();
1373 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1374 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1376 Assertions.assertThrows(ComponentException.class, () -> sIBL
1377 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1378 currentCompInstance, instInputs, allDataTypes));
1382 void testProcessProperty2() {
1383 Service resource = createServiceObject(true);
1384 List<InputDefinition> inputs = new ArrayList<>();
1385 ComponentInstance currentCompInstance = null;
1386 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1387 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1388 InputDefinition inputDefinition = new InputDefinition();
1389 inputDefinition.setName("inputDefinitionName");
1390 inputDefinition.setType("inputDefinitionType");
1391 inputs.add(inputDefinition);
1392 currPropertiesMap.put("propertyInfoName", inputDefinition);
1393 resource.setInputs(inputs);
1394 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1395 List<UploadPropInfo> propertyList = new ArrayList<>();
1396 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1397 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1398 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1399 getInputValueDataDefinition.setInputName("inputDefinitionName");
1400 get_input.add(getInputValueDataDefinition);
1401 UploadPropInfo propertyInfo = new UploadPropInfo();
1402 propertyInfo.setValue("value");
1403 propertyInfo.setGet_input(get_input);
1404 propertyInfo.setName("propertyInfoName");
1405 propertyList.add(propertyInfo);
1406 Assertions.assertNotNull(resource);
1408 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1412 void testProcessGetInput() {
1413 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1414 List<InputDefinition> inputs = new ArrayList<>();
1415 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1417 Assertions.assertThrows(ComponentException.class, () -> sIBL.processGetInput(getInputValues, inputs, getInputIndex));
1421 void testProcessGetInput_optional() {
1422 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1423 List<InputDefinition> inputs = new ArrayList<>();
1424 InputDefinition inputDefinition = new InputDefinition();
1425 inputDefinition.setUniqueId("uniqueId");
1426 inputDefinition.setName("InputName");
1427 inputs.add(inputDefinition);
1428 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1429 getInputIndex.setInputName("InputName");
1430 Assertions.assertNotNull(inputs);
1432 sIBL.processGetInput(getInputValues, inputs, getInputIndex);
1436 void testAddPropertyValuesToRi() {
1437 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1438 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1439 Resource resource = createParseResourceObject(true);
1440 List<InputDefinition> inputs = new ArrayList<>();
1441 InputDefinition inputDefinition = new InputDefinition();
1442 inputDefinition.setName("inputDefinitionName");
1443 inputDefinition.setUniqueId("uniqueId");
1444 inputDefinition.setType("inputDefinitionType");
1445 inputs.add(inputDefinition);
1446 resource.setInputs(inputs);
1447 Resource originResource = createParseResourceObject(false);
1448 originResource.setProperties(getProperties());
1449 ComponentInstance currentCompInstance = new ComponentInstance();
1450 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1451 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1452 ResponseFormat responseFormat = new ResponseFormat();
1453 when(serviceImportParseLogic.findInputByName(eq(inputs), any(GetInputValueDataDefinition.class)))
1454 .thenReturn(inputDefinition);
1455 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1456 Assertions.assertNotNull(
1457 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1458 currentCompInstance, instProperties, allDataTypes));
1462 void testAddPropertyValuesToRi_else() {
1463 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1464 Resource resource = createParseResourceObject(true);
1465 Resource originResource = createParseResourceObject(false);
1466 originResource.setProperties(getProperties());
1467 ComponentInstance currentCompInstance = new ComponentInstance();
1468 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1469 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1470 ResponseFormat responseFormat = new ResponseFormat();
1471 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1472 Assertions.assertNotNull(
1473 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
1474 instProperties, allDataTypes));
1478 void testAddPropertyValuesToRi2() {
1479 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1480 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1481 Service service = createServiceObject(true);
1482 List<InputDefinition> inputs = new ArrayList<>();
1483 InputDefinition inputDefinition = new InputDefinition();
1484 inputDefinition.setName("inputDefinitionName");
1485 inputDefinition.setUniqueId("uniqueId");
1486 inputDefinition.setType("inputDefinitionType");
1487 inputs.add(inputDefinition);
1488 service.setInputs(inputs);
1489 Resource originResource = createParseResourceObject(false);
1490 originResource.setProperties(getProperties());
1491 ComponentInstance currentCompInstance = new ComponentInstance();
1492 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1493 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1494 ResponseFormat responseFormat = new ResponseFormat();
1495 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1496 when(serviceImportParseLogic.findInputByName(anyList(), any(GetInputValueDataDefinition.class)))
1497 .thenReturn(inputDefinition);
1498 Assertions.assertNotNull(
1499 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource,
1500 currentCompInstance, instProperties, allDataTypes));
1504 void testAddPropertyValuesToRi2_else() {
1505 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1506 Service service = createServiceObject(true);
1507 Resource originResource = createParseResourceObject(false);
1508 originResource.setProperties(getProperties());
1509 ComponentInstance currentCompInstance = new ComponentInstance();
1510 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1511 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1512 ResponseFormat responseFormat = new ResponseFormat();
1513 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1514 Assertions.assertNotNull(
1515 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1516 instProperties, allDataTypes));
1520 void testProcessComponentInstanceCapabilities() {
1521 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1522 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1523 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1524 uploadComponentInstanceInfo.setCapabilities(getCapabilities());
1525 ComponentInstance currentCompInstance = new ComponentInstance();
1526 Resource originResource = createParseResourceObject(false);
1527 Assertions.assertNotNull(originResource);
1528 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1533 void testProcessComponentInstanceCapabilities_null() {
1534 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1535 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1536 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1537 ComponentInstance currentCompInstance = new ComponentInstance();
1538 Resource originResource = createParseResourceObject(false);
1539 Assertions.assertNotNull(originResource);
1541 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1546 void testUpdateCapabilityPropertiesValues() {
1547 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1548 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1549 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1550 Assertions.assertNull(allDataTypes);
1551 sIBL.updateCapabilityPropertiesValues(null, originCapabilities, newPropertiesMap);
1555 void testUpdatePropertyValues() {
1556 List<ComponentInstanceProperty> properties = new ArrayList<>();
1557 Map<String, UploadPropInfo> newProperties = new HashMap<>();
1558 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1559 Assertions.assertNotNull(allDataTypes);
1560 sIBL.updatePropertyValues(properties, newProperties, allDataTypes);
1564 void testUpdatePropertyValue() {
1565 ComponentInstanceProperty property = new ComponentInstanceProperty();
1566 property.setType("services");
1567 UploadPropInfo propertyInfo = new UploadPropInfo();
1568 propertyInfo.setValue("value");
1569 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1570 when(serviceBusinessLogic.validatePropValueBeforeCreate(any(IPropertyInputCommon.class), anyString(), anyBoolean(), anyMap())).thenReturn(
1572 Assertions.assertNotNull(sIBL.updatePropertyValue(property, propertyInfo, allDataTypes));
1576 void testGetOriginResource() {
1577 String yamlName = "group.yml";
1578 Map<String, Resource> originCompMap = new HashMap<>();
1579 ComponentInstance currentCompInstance = new ComponentInstance();
1580 currentCompInstance.setComponentUid("currentCompInstance");
1581 when(toscaOperationFacade.getToscaFullElement(anyString()))
1582 .thenReturn(Either.left(createParseResourceObject(true)));
1583 Assertions.assertNotNull(sIBL.getOriginResource(yamlName, originCompMap, currentCompInstance));
1587 void testUpdateCalculatedCapReqWithSubstitutionMappings() {
1588 Resource resource = createParseResourceObject(false);
1589 resource.setComponentInstances(creatComponentInstances());
1590 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1592 when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
1593 Assertions.assertNotNull(sIBL.updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap));
1597 void testFillUpdatedInstCapabilitiesRequirements() {
1598 List<ComponentInstance> componentInstances = creatComponentInstances();
1599 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1600 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1601 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
1602 Assertions.assertNotNull(componentInstances);
1604 sIBL.fillUpdatedInstCapabilitiesRequirements(componentInstances, uploadResInstancesMap,
1605 updatedInstCapabilities, updatedInstRequirement);
1609 void testFillUpdatedInstCapabilities() {
1610 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
1611 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1612 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1613 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1614 capabilityDefinition.setName("mme_ipu_vdu.feature");
1615 capabilityDefinitionList.add(capabilityDefinition);
1616 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
1617 ComponentInstance instance = new ComponentInstance();
1618 instance.setCapabilities(capabilities);
1619 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1620 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
1621 Assertions.assertNotNull(instance);
1623 sIBL.fillUpdatedInstCapabilities(updatedInstCapabilties, instance, capabilitiesNamesToUpdate);
1627 void testFillUpdatedInstRequirements() {
1628 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
1630 ComponentInstance instance = new ComponentInstance();
1631 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1632 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1633 RequirementDefinition requirementDefinition = new RequirementDefinition();
1634 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1635 requirementDefinitionList.add(requirementDefinition);
1636 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
1637 instance.setRequirements(requirements);
1638 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1639 requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
1640 "requirementsNamesToUpdate");
1641 Assertions.assertNotNull(instance);
1643 sIBL.fillUpdatedInstRequirements(updatedInstRequirements, instance, requirementsNamesToUpdate);
1647 void testAddRelationsToRI() {
1648 String yamlName = "group.yml";
1649 Service service = createServiceObject(true);
1651 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1652 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1653 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1654 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1655 ComponentInstance componentInstance = new ComponentInstance();
1656 componentInstance.setName("zxjTestImportServiceAb");
1657 componentInstancesList.add(componentInstance);
1658 service.setComponentInstances(componentInstancesList);
1659 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1660 RequirementDefinition requirementDefinition = new RequirementDefinition();
1661 requirementDefinition.setOwnerId("1");
1662 requirementDefinition.setUniqueId("2");
1663 requirementDefinition.setCapability("3");
1664 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1665 capabilityDefinition.setName("4");
1666 capabilityDefinition.setUniqueId("5");
1667 capabilityDefinition.setOwnerId("6");
1668 ResponseFormat responseFormat = new ResponseFormat();
1669 responseFormat.setStatus(200);
1670 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1671 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1672 anyString())).thenReturn(Either.left(requirementDefinition));
1673 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1674 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1675 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1676 Assertions.assertNotNull(service);
1678 sIBL.addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1682 void testAddRelationsToRI_null() {
1683 String yamlName = "group.yml";
1684 Service service = createServiceObject(true);
1685 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1686 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1687 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1688 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1689 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1691 Assertions.assertThrows(ComponentException.class, () -> sIBL.addRelationsToRI(yamlName,
1692 service, uploadResInstancesMap, componentInstancesList, relations));
1696 void testAddRelationToRI() {
1697 String yamlName = "group.yml";
1698 Service service = createServiceObject(true);
1699 service.setComponentInstances(creatComponentInstances());
1701 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1702 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1703 RequirementDefinition requirementDefinition = new RequirementDefinition();
1704 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1705 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1706 capabilityDefinition.setName("capabilityDefinitionName");
1707 capabilityDefinition.setUniqueId("capabilityDefinitionUniqueId");
1708 capabilityDefinition.setOwnerId("capabilityDefinitionOwnerId");
1709 ResponseFormat responseFormat = new ResponseFormat();
1710 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
1711 any(ComponentInstance.class), anyString())).thenReturn(Either.left(requirementDefinition));
1712 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1713 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1714 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1715 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1716 Assertions.assertNotNull(relations.get(0).getRelationships().get(0).getOperations());
1720 void testAddRelationToRI_null() {
1721 String yamlName = "group.yml";
1722 Service service = createServiceObject(true);
1723 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1724 service.setComponentInstances(componentInstancesList);
1725 ResponseFormat responseFormat = new ResponseFormat();
1726 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1727 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1728 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1729 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1733 void testGetResourceAfterCreateRelations() {
1734 Service service = createServiceObject(true);
1735 ComponentParametersView componentParametersView = createComponentParametersView();
1736 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1737 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1738 .thenReturn(Either.left(createServiceObject(true)));
1739 Assertions.assertNotNull(sIBL.getResourceAfterCreateRelations(service));
1743 void testCreateServiceInstances() {
1744 String yamlName = "group.yml";
1745 Service service = createServiceObject(true);
1746 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1747 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1748 uploadResInstancesMap.put("uploadResInstancesMap", nodesInfoValue);
1749 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1750 Resource resource = createParseResourceObject(true);
1751 resource.setToscaResourceName("toscaResourceName");
1752 nodeNamespaceMap.put("nodeNamespaceMap", resource);
1754 Assertions.assertThrows(ComponentException.class,
1755 () -> sIBL.createServiceInstances(yamlName, service, uploadResInstancesMap, nodeNamespaceMap));
1759 void testCreateAndAddResourceInstance() {
1760 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1761 String yamlName = "group.yml";
1762 Resource resource = createParseResourceObject(false);
1763 Resource originResource = createParseResourceObject(true);
1764 originResource.setResourceType(ResourceTypeEnum.VF);
1765 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1766 nodeNamespaceMap.put("resources", originResource);
1767 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1768 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1770 Assertions.assertThrows(ComponentException.class, () -> sIBL
1771 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, resource,
1772 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1776 void testCreateAndAddResourceInstances() {
1777 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1778 String yamlName = "group.yml";
1779 Service service = createServiceObject(true);
1780 service.setServiceType("services");
1781 Resource originResource = createParseResourceObject(true);
1782 originResource.setResourceType(ResourceTypeEnum.VF);
1783 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1784 nodeNamespaceMap.put("resources", originResource);
1785 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1786 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1788 Assertions.assertThrows(ComponentException.class, () -> sIBL
1789 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service,
1790 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1794 void testValidateResourceInstanceBeforeCreate() {
1795 String yamlName = "group.yml";
1796 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1797 Resource originResource = createParseResourceObject(true);
1798 ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
1799 componentMetadataDataDefinition.setState(LifecycleStateEnum.CERTIFIED.name());
1800 ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
1801 originResource.setComponentMetadataDefinition(componentMetadataDefinition);
1802 originResource.setComponentType(ComponentTypeEnum.RESOURCE);
1803 originResource.setToscaResourceName("toscaResourceName");
1804 originResource.setResourceType(ResourceTypeEnum.VF);
1805 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1806 nodeNamespaceMap.put("resources", originResource);
1807 when(toscaOperationFacade.getLatestByToscaResourceName(RESOURCE_TOSCA_NAME, null)).thenReturn(Either.left(originResource));
1808 Assertions.assertNotNull(
1809 sIBL.validateResourceInstanceBeforeCreate(yamlName, null, uploadComponentInstanceInfo, nodeNamespaceMap));
1813 void testHandleServiceNodeTypes() {
1814 String yamlName = "group.yml";
1815 Service service = createServiceObject(true);
1816 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1818 boolean needLock = true;
1819 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1820 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1821 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1822 CsarInfo csarInfo = getCsarInfo();
1823 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1824 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
1825 Assertions.assertNotNull(service);
1827 sIBL.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1828 nodeTypesNewCreatedArtifacts,
1829 nodeTypesInfo, csarInfo, nodeName);
1833 void testValidateResourceNotExisted() {
1834 String type = "org.openecomp.resource.vf";
1836 Assertions.assertThrows(ComponentException.class, () -> sIBL.validateResourceNotExisted(type));
1840 void testHandleNestedVF() {
1841 Service service = createServiceObject(true);
1842 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1843 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1844 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1845 CsarInfo csarInfo = getCsarInfo();
1846 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1848 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVF(service,
1849 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1853 void testHandleNestedVfc() {
1854 Service service = createServiceObject(true);
1855 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1856 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1857 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1858 CsarInfo csarInfo = getCsarInfo();
1859 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1861 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(service,
1862 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1866 void testHandleComplexVfc() {
1867 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1868 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1869 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1870 CsarInfo csarInfo = getCsarInfo();
1871 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1872 String yamlName = "group.yml";
1873 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1874 .thenReturn(createNewResource());
1875 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1876 .thenReturn(Either.left(createNewResource()));
1877 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class), anyBoolean()))
1878 .thenReturn(Either.left(true));
1880 Assertions.assertThrows(ComponentException.class, () -> sIBL
1881 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1882 csarInfo, nodeName, yamlName));
1886 void testHandleComplexVfcStatus() {
1887 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1888 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1889 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1890 CsarInfo csarInfo = getCsarInfo();
1891 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1892 String yamlName = "group.yml";
1893 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1894 .thenReturn(createNewResource());
1895 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1896 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1898 Assertions.assertThrows(ComponentException.class, () -> sIBL
1899 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1900 csarInfo, nodeName, yamlName));
1904 void testHandleComplexVfc2() {
1905 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1906 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1907 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1908 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1909 String yamlName = "group.yml";
1910 CsarInfo csarInfo = getCsarInfo();
1911 Map<String, byte[]> csar = new HashMap<>();
1912 csar.put(yamlName, yamlName.getBytes());
1913 csarInfo.setCsar(csar);
1914 Resource oldComplexVfc = createParseResourceObject(false);
1915 Resource newComplexVfc = createParseResourceObject(true);
1917 Assertions.assertThrows(ComponentException.class, () -> sIBL
1918 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1919 csarInfo, nodeName, yamlName, oldComplexVfc, newComplexVfc));
1923 void testUpdateResourceFromYaml() throws IOException {
1924 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1925 Resource newResource = createNewResource();
1926 Resource oldResource = createOldResource();
1927 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1928 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1929 String yamlFileName = "group.yml";
1930 String yamlFileContent = getYamlFileContent();
1931 CsarInfo csarInfo = getCsarInfo();
1932 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1933 Map<String, Object> map = new HashMap<>();
1934 map.put("tosca_definitions_version", "123");
1935 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1936 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1937 boolean isNested = true;
1939 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1940 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1941 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
1942 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
1943 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
1944 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
1945 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
1946 .thenReturn(Either.left(newResource));
1947 Assertions.assertThrows(ComponentException.class, () -> sIBL
1948 .updateResourceFromYaml(oldResource, newResource, actionEnum, createdArtifacts,
1949 yamlFileName, yamlFileContent, csarInfo, nodeTypesInfo,
1950 nodeTypesArtifactsToHandle, nodeName, isNested));
1954 void testCreateResourceFromYaml() throws IOException {
1955 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1956 Resource resource = createParseResourceObject(true);
1957 String topologyTemplateYaml = getMainTemplateContent();
1958 String yamlName = "group.yml";
1960 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1961 Map<String, Object> map = new HashMap<>();
1962 map.put("tosca_definitions_version", "123");
1963 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1965 CsarInfo csarInfo = getCsarInfo();
1966 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1967 boolean shouldLock = false;
1968 boolean inTransaction = true;
1970 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1971 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1972 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Component.class))).thenReturn(resource);
1973 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
1974 .thenReturn(Either.left(false));
1975 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
1976 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceFromYaml(resource,
1977 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
1978 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
1982 void testCreateResourceAndRIsFromYaml() throws IOException {
1983 String yamlName = "group.yml";
1984 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1985 Resource resource = createParseResourceObject(true);
1986 resource.setSystemName("SystemName");
1987 resource.setComponentType(ComponentTypeEnum.RESOURCE);
1988 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1989 boolean isNormative = true;
1990 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1991 String topologyTemplateYaml = getMainTemplateContent();
1992 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1993 Map<String, Object> map = new HashMap<>();
1994 map.put("tosca_definitions_version", "123");
1995 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1996 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1998 CsarInfo csarInfo = getCsarInfo();
1999 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
2000 boolean shouldLock = false;
2001 boolean inTransaction = true;
2002 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Resource.class)))
2003 .thenReturn(resource);
2005 when(serviceBusinessLogic.lockComponentByName(anyString(), any(), anyString()))
2006 .thenReturn(Either.left(true));
2008 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2009 .thenReturn(Either.left(false));
2011 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2013 Assertions.assertThrows(ComponentException.class, () -> sIBL
2014 .createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, actionEnum,
2015 isNormative, createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo,
2016 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
2020 void testCreateGroupsOnResource2() {
2021 Resource resource = createParseResourceObject(false);
2022 Map<String, GroupDefinition> groups = null;
2023 List<GroupDefinition> groupDefinitionList = new ArrayList<>();
2024 GroupDefinition groupDefinition = new GroupDefinition();
2025 groupDefinition.setUniqueId("groupDefinitionUniqueId");
2026 groupDefinition.setName("groupDefinition");
2027 groupDefinitionList.add(groupDefinition);
2029 Assertions.assertNotNull(
2030 sIBL.createGroupsOnResource(resource, groups));
2034 void testCreateGroupsOnResource2_null() {
2035 Resource resource = createParseResourceObject(false);
2036 Map<String, GroupDefinition> groups = null;
2038 Either<Resource, ResponseFormat> result = sIBL.createGroupsOnResource(resource, groups);
2039 assertEquals(result.left().value(), resource);
2043 void testUpdateGroupsMembersUsingResource2() {
2044 Resource resource = createParseResourceObject(true);
2045 Map<String, GroupDefinition> groups = getGroups();
2047 Assertions.assertNotNull(
2048 sIBL.updateGroupsMembersUsingResource(groups, resource));
2052 void testUpdateGroupsMembersUsingResource_left2() {
2053 Resource resource = createParseResourceObject(true);
2054 Map<String, GroupDefinition> groups = getGroups();
2056 Assertions.assertNotNull(
2057 sIBL.updateGroupsMembersUsingResource(groups, resource));
2061 void testUpdateGroupMembers() throws IOException {
2062 Map<String, GroupDefinition> groups = new HashMap<>();
2063 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2064 Resource component = createParseResourceObject(true);
2065 List<ComponentInstance> componentInstances = creatComponentInstances();
2066 String groupName = "tosca_simple_yaml_1_1";
2067 Map<String, String> members = new HashMap<>();
2068 members.put("zxjTestImportServiceAb", getGroupsYaml());
2069 Assertions.assertNotNull(component);
2071 sIBL.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2075 void testUpdateGroupMembers_null() throws IOException {
2076 Map<String, GroupDefinition> groups = new HashMap<>();
2077 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2078 Resource component = createParseResourceObject(true);
2079 List<ComponentInstance> componentInstances = new ArrayList<>();
2080 String groupName = "tosca_simple_yaml_1_1";
2081 Map<String, String> members = new HashMap<>();
2082 members.put("zxjTestImportServiceAb", getGroupsYaml());
2084 Assertions.assertThrows(ComponentException.class, () -> sIBL.updateGroupMembers(groups,
2085 updatedGroupDefinition, component, componentInstances, groupName, members));
2089 void setCreateResourceTransaction() {
2090 Resource resource = createParseResourceObject(false);
2091 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2092 boolean isNormative = true;
2093 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2094 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
2096 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2100 void setCreateResourceTransaction_leftTrue() {
2101 Resource resource = createParseResourceObject(false);
2102 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2103 boolean isNormative = true;
2104 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(true));
2106 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2110 void setCreateResourceTransaction_Left() {
2111 Resource resource = createParseResourceObject(false);
2112 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2113 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(false));
2114 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2115 Assertions.assertNotNull(sIBL.createResourceTransaction(resource, user, false));
2119 void testUpdateExistingResourceByImport() {
2120 Resource newResource = createNewResource();
2121 Resource oldResource = createOldResource();
2122 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
2123 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
2124 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
2125 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
2126 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
2127 .thenReturn(Either.left(newResource));
2128 Assertions.assertNotNull(sIBL.updateExistingResourceByImport(newResource, oldResource, user, true, false, true));
2132 void testCreateNewResourceToOldResource() {
2133 Resource newResource = createNewResource();
2134 Resource oldResource = createOldResource();
2136 sIBL.createNewResourceToOldResource(newResource, oldResource, user);
2137 assertEquals(newResource.getSystemName(), oldResource.getSystemName());
2141 void testCreateResourcesFromYamlNodeTypesList() {
2142 String yamlName = "group.yml";
2143 Service service = createServiceObject(true);
2144 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2145 boolean needLock = true;
2146 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2147 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2148 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2149 CsarInfo csarInfo = getCsarInfo();
2151 Assertions.assertThrows(ComponentException.class, () -> sIBL
2152 .createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock,
2153 nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo));
2157 void testCreateNodeTypes() {
2158 String yamlName = "group.yml";
2159 Service service = createServiceObject(true);
2160 boolean needLock = true;
2161 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2162 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2163 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2164 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2165 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2166 artifactDefinition.setArtifactName("artifactName");
2167 artifactDefinitions.add(artifactDefinition);
2168 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2169 artifactDefinitions);
2170 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2171 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2172 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2173 CsarInfo csarInfo = getCsarInfo();
2174 Map<String, Object> mapToConvert = new HashMap<>();
2175 Map<String, Object> nodeTypes = new HashMap<>();
2176 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2177 nodeTypesInfo.put("nodeTyp", nodeTypeInfo);
2178 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2181 Assertions.assertThrows(ComponentException.class, () -> sIBL.createNodeTypes(yamlName,
2182 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2183 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes));
2187 void testCreateNodeTypesElse() {
2188 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2189 String yamlName = "group.yml";
2190 Service service = createServiceObject(true);
2191 boolean needLock = true;
2192 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2193 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2194 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2195 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2196 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2197 artifactDefinition.setArtifactName("artifactName");
2198 artifactDefinitions.add(artifactDefinition);
2199 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2200 artifactDefinitions);
2201 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2202 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2203 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2204 Map<String, Object> map = new HashMap<>();
2205 map.put("tosca_definitions_version", "123");
2206 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
2207 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
2209 CsarInfo csarInfo = getCsarInfo();
2210 Map<String, Object> mapToConvert = new HashMap<>();
2211 Map<String, Object> nodeTypes = new HashMap<>();
2212 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2213 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2215 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class),
2216 anyMap(), any(Service.class), anyBoolean(), anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
2217 anyBoolean())).thenReturn(getResourceCreated());
2218 Assertions.assertNotNull(service);
2220 sIBL.createNodeTypes(yamlName,
2221 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2222 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
2225 protected ImmutablePair<Resource, ActionStatus> getResourceCreated() {
2226 Resource resource = createOldResource();
2227 ImmutablePair<Resource, ActionStatus> resourceCreated = new ImmutablePair<>(resource, ActionStatus.OK);
2229 return resourceCreated;
2232 protected Resource createNewResource() {
2233 Resource newResource = createParseResourceObject(false);
2234 newResource.setVersion("1.0");
2235 newResource.setInvariantUUID("");
2236 newResource.setLifecycleState(null);
2237 newResource.setUUID("");
2238 newResource.setNormalizedName("");
2239 newResource.setSystemName("");
2240 newResource.setCsarUUID("");
2241 newResource.setImportedToscaChecksum("");
2242 newResource.setDerivedFromGenericType("");
2243 newResource.setDerivedFromGenericVersion("");
2244 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2245 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2246 artifactDefinition.setArtifactName("artifactDefinition");
2247 toscaArtifacts.put("toscaArtifactsMap", artifactDefinition);
2248 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2249 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2250 interfaceDefinition.setOwnerId("OwnerId");
2251 interfaces.put("interfacesMap", interfaceDefinition);
2252 newResource.setInterfaces(interfaces);
2253 newResource.setToscaArtifacts(toscaArtifacts);
2254 newResource.setProperties(getProperties());
2258 protected Resource createOldResource() {
2259 Resource newResource = createParseResourceObject(false);
2260 newResource.setVersion("1.0");
2261 newResource.setUniqueId("ResourceUniqueId");
2262 newResource.setInvariantUUID("552e8f6c-340c-4fb4-8a82-fe7732fd8010");
2263 newResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
2264 newResource.setUUID("13065b80-ca96-4331-b643-d28aeaf961cb");
2265 newResource.setNormalizedName("NormalizedName");
2266 newResource.setSystemName("default");
2267 newResource.setCsarUUID("CsarUUID");
2268 newResource.setImportedToscaChecksum("ImportedToscaChecksum");
2269 newResource.setDerivedFromGenericType("DerivedFromGenericType");
2270 newResource.setDerivedFromGenericVersion("0.1");
2271 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2272 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2273 artifactDefinition.setArtifactName("tosca_simple_yaml_1_1");
2274 toscaArtifacts.put("tosca_definitions_version", artifactDefinition);
2275 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2276 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2277 interfaceDefinition.setDescription("Invoked upon receipt of an Instantiate VNF request");
2278 interfaces.put("tosca_simple_yaml_1_1", interfaceDefinition);
2279 newResource.setInterfaces(interfaces);
2280 newResource.setToscaArtifacts(toscaArtifacts);
2281 List<PropertyDefinition> properties = new ArrayList<>();
2282 PropertyDefinition propertyDefinition = new PropertyDefinition();
2283 propertyDefinition.setName("tosca_simple_yaml_1_1");
2284 properties.add(propertyDefinition);
2285 newResource.setProperties(properties);
2289 protected Map<String, InputDefinition> getCurrPropertiesMap() {
2290 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2291 InputDefinition inputDefinition = new InputDefinition();
2292 inputDefinition.setName("inputDefinitionName");
2293 inputDefinition.setUniqueId("uniqueId");
2294 inputDefinition.setType("inputDefinitionType");
2295 currPropertiesMap.put("propertyInfoName", inputDefinition);
2296 return currPropertiesMap;
2299 protected List<UploadPropInfo> getPropertyList() {
2300 List<UploadPropInfo> propertyList = new ArrayList<>();
2301 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2302 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2303 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2304 getInputValueDataDefinition.setInputName("inputDefinitionName");
2305 get_input.add(getInputValueDataDefinition);
2306 UploadPropInfo propertyInfo = new UploadPropInfo();
2307 propertyInfo.setValue("value");
2308 propertyInfo.setGet_input(get_input);
2309 propertyInfo.setName("propertyInfoName");
2310 propertyList.add(propertyInfo);
2311 return propertyList;
2314 private Map<String, NodeTypeInfo> getNodeTypesInfo() {
2315 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2316 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2317 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2318 nodeTypeInfo.setNested(true);
2319 nodeTypeInfo.setTemplateFileName("templateFileName");
2320 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2321 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2322 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2323 return nodeTypesInfo;
2326 private Map<String, Object> getNodeTypes() {
2327 Map<String, Object> nodeTypesInfo = new HashMap<>();
2328 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2329 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2330 nodeTypeInfo.setNested(true);
2331 nodeTypeInfo.setTemplateFileName("templateFileName");
2332 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2333 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2334 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2335 return nodeTypesInfo;
2338 private Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap() {
2339 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
2340 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2341 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
2342 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2343 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
2344 requirementsNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2345 uploadResInstancesMap.put("zxjTestImportServiceAb", uploadComponentInstanceInfo);
2346 return uploadResInstancesMap;
2349 protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties() {
2350 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
2351 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
2352 UploadPropInfo uploadPropInfo = new UploadPropInfo();
2353 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2354 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2355 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2356 get_input.add(getInputValueDataDefinition);
2357 uploadPropInfo.setName("propertiesName");
2358 uploadPropInfo.setValue("value");
2359 uploadPropInfo.setGet_input(get_input);
2360 uploadPropInfoList.add(uploadPropInfo);
2361 properties.put("uploadComponentInstanceInfo", uploadPropInfoList);
2365 protected List<PropertyDefinition> getProperties() {
2366 List<PropertyDefinition> properties = new ArrayList<>();
2367 PropertyDefinition propertyDefinition = new PropertyDefinition();
2368 propertyDefinition.setName("propertiesName");
2369 properties.add(propertyDefinition);
2373 protected Map<String, List<UploadReqInfo>> gerRequirements() {
2374 Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
2375 String requirementName = "tosca.capabilities.Node";
2376 List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
2377 UploadReqInfo uploadReqInfo = new UploadReqInfo();
2378 uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
2379 uploadReqInfoMap.put(requirementName, uploadReqInfoList);
2380 return uploadReqInfoMap;
2383 protected ComponentParametersView createComponentParametersView() {
2384 ComponentParametersView parametersView = new ComponentParametersView();
2385 parametersView.disableAll();
2386 parametersView.setIgnoreComponentInstances(false);
2387 parametersView.setIgnoreComponentInstancesProperties(false);
2388 parametersView.setIgnoreCapabilities(false);
2389 parametersView.setIgnoreRequirements(false);
2390 parametersView.setIgnoreGroups(false);
2391 return parametersView;
2394 protected Map<String, byte[]> crateCsarFromPayload() {
2395 String payloadName = "valid_vf.csar";
2396 String rootPath = System.getProperty("user.dir");
2400 Map<String, byte[]> returnValue = null;
2402 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2403 data = Files.readAllBytes(path);
2404 payloadData = Base64.encodeBase64String(data);
2405 UploadResourceInfo resourceInfo = new UploadResourceInfo();
2406 resourceInfo.setPayloadName(payloadName);
2407 resourceInfo.setPayloadData(payloadData);
2408 Method privateMethod = null;
2409 privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
2410 privateMethod.setAccessible(true);
2411 returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
2412 } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException |
2413 InvocationTargetException e) {
2414 e.printStackTrace();
2419 protected List<ComponentInstance> creatComponentInstances() {
2420 List<ComponentInstance> componentInstances = new ArrayList<>();
2421 ComponentInstance componentInstance = new ComponentInstance();
2422 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2423 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
2424 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
2425 capabilityDefinition.setName("mme_ipu_vdu.feature");
2426 capabilityDefinitionList.add(capabilityDefinition);
2427 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
2429 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2430 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2431 RequirementDefinition requirementDefinition = new RequirementDefinition();
2432 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
2433 requirementDefinitionList.add(requirementDefinition);
2434 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
2435 componentInstance.setRequirements(requirements);
2436 componentInstance.setCapabilities(capabilities);
2437 componentInstance.setUniqueId("uniqueId");
2438 componentInstance.setComponentUid("componentUid");
2439 componentInstance.setName("zxjTestImportServiceAb");
2440 componentInstance.setNormalizedName("zxjTestImportServiceAb");
2441 componentInstance.setProperties(getProperties());
2442 componentInstances.add(componentInstance);
2443 return componentInstances;
2446 private CreateServiceFromYamlParameter getCsfyp() {
2447 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
2448 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2449 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2451 csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
2452 csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
2453 csfyp.setCreatedArtifacts(createdArtifacts);
2454 csfyp.setInTransaction(true);
2455 csfyp.setShouldLock(true);
2456 csfyp.setCsarInfo(getCsarInfo());
2457 csfyp.setParsedToscaYamlInfo(getParsedToscaYamlInfo());
2458 csfyp.setNodeTypesInfo(nodeTypesInfo);
2459 csfyp.setYamlName("group.yml");
2463 private ParsedToscaYamlInfo getParsedToscaYamlInfo() {
2464 ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
2465 Map<String, InputDefinition> inputs = new HashMap<>();
2466 Map<String, UploadComponentInstanceInfo> instances = new HashMap<>();
2467 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2468 instances.put("instances", uploadComponentInstanceInfo);
2469 Map<String, GroupDefinition> groups = new HashMap<>();
2470 Map<String, PolicyDefinition> policies = new HashMap<>();
2471 parsedToscaYamlInfo.setGroups(groups);
2472 parsedToscaYamlInfo.setInputs(inputs);
2473 parsedToscaYamlInfo.setInstances(instances);
2474 parsedToscaYamlInfo.setPolicies(policies);
2475 return parsedToscaYamlInfo;
2478 String getMainTemplateContent(String fileName) {
2479 String mainTemplateContent = null;
2481 mainTemplateContent = loadFileNameToJsonString(fileName);
2482 } catch (IOException e) {
2483 e.printStackTrace();
2485 return mainTemplateContent;
2488 protected ServiceCsarInfo getCsarInfo() {
2489 String csarUuid = "0010";
2490 User user = new User("jh0003");
2493 File csarFile = new File(
2494 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
2495 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
2497 String vfReousrceName = "resouceName";
2498 String mainTemplateName = "Definitions/service_import_template.yml";
2500 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
2501 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
2502 assertNotNull(mainTemplateService);
2503 final String mainTemplateContent = new String(mainTemplateService);
2505 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false, mock(ModelOperation.class));
2506 } catch (URISyntaxException | ZipException e) {
2512 private ImmutablePair<String, byte[]> getNodeType() {
2514 File resource = new File(
2515 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("node-types/resource-Extcp-template.yml").toURI());
2516 byte[] extcpResource = Files.readAllBytes(resource.toPath());
2518 return new ImmutablePair<>("org.openecomp.resource.cp.extCP", extcpResource);
2519 } catch (URISyntaxException | IOException e) {
2525 protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo() {
2526 String artifactName = "artifactName", path = "/src/test/resources/valid_vf.csar", artifactType = "AAI_SERVICE_MODEL";
2527 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
2528 String rootPath = System.getProperty("user.dir");
2530 byte[] data = new byte[0];
2531 path2 = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2533 data = Files.readAllBytes(path2);
2534 } catch (IOException e) {
2535 e.printStackTrace();
2537 String artifactUniqueId = "artifactUniqueId";
2538 boolean isFromCsar = true;
2539 CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
2540 path, artifactType, artifactGroupType, data, artifactUniqueId, isFromCsar);
2541 return nonMetaArtifactInfo;
2545 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2546 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2547 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2548 assertParseResponse(actualResponse, expectedStatus, variables);
2551 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2552 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2553 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2554 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());