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.eq;
31 import static org.mockito.Mockito.isNull;
32 import static org.mockito.Mockito.matches;
33 import static org.mockito.Mockito.mock;
34 import static org.mockito.Mockito.verify;
35 import static org.mockito.Mockito.when;
36 import static org.openecomp.sdc.be.components.impl.ServiceImportBusinessLogic.CREATE_RESOURCE;
38 import fj.data.Either;
40 import java.io.IOException;
41 import java.lang.reflect.InvocationTargetException;
42 import java.lang.reflect.Method;
43 import java.net.URISyntaxException;
44 import java.nio.file.FileSystems;
45 import java.nio.file.Files;
46 import java.nio.file.Path;
47 import java.nio.file.Paths;
48 import java.util.ArrayList;
49 import java.util.Collections;
50 import java.util.EnumMap;
51 import java.util.HashMap;
52 import java.util.List;
54 import java.util.Optional;
56 import org.apache.commons.codec.binary.Base64;
57 import org.apache.commons.collections.map.HashedMap;
58 import org.apache.commons.lang3.tuple.ImmutablePair;
59 import org.json.simple.JSONObject;
60 import org.junit.jupiter.api.Assertions;
61 import org.junit.jupiter.api.BeforeEach;
62 import org.junit.jupiter.api.Test;
63 import org.mockito.ArgumentCaptor;
64 import org.mockito.InjectMocks;
65 import org.mockito.MockitoAnnotations;
66 import org.openecomp.sdc.be.components.csar.CsarInfo;
67 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
68 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
69 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
70 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
71 import org.openecomp.sdc.be.dao.api.ActionStatus;
72 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
73 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
75 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
76 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
77 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
78 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
79 import org.openecomp.sdc.be.externalapi.servlet.ArtifactExternalServlet;
80 import org.openecomp.sdc.be.impl.ServletUtils;
81 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
82 import org.openecomp.sdc.be.model.ArtifactDefinition;
83 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
84 import org.openecomp.sdc.be.model.AttributeDefinition;
85 import org.openecomp.sdc.be.model.CapabilityDefinition;
86 import org.openecomp.sdc.be.model.Component;
87 import org.openecomp.sdc.be.model.ComponentInstance;
88 import org.openecomp.sdc.be.model.ComponentInstanceInput;
89 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
90 import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
91 import org.openecomp.sdc.be.model.ComponentParametersView;
92 import org.openecomp.sdc.be.model.DataTypeDefinition;
93 import org.openecomp.sdc.be.model.GroupDefinition;
94 import org.openecomp.sdc.be.model.GroupTypeDefinition;
95 import org.openecomp.sdc.be.model.IPropertyInputCommon;
96 import org.openecomp.sdc.be.model.InputDefinition;
97 import org.openecomp.sdc.be.model.InterfaceDefinition;
98 import org.openecomp.sdc.be.model.LifecycleStateEnum;
99 import org.openecomp.sdc.be.model.NodeTypeInfo;
100 import org.openecomp.sdc.be.model.Operation;
101 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
102 import org.openecomp.sdc.be.model.PolicyDefinition;
103 import org.openecomp.sdc.be.model.PropertyDefinition;
104 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
105 import org.openecomp.sdc.be.model.RequirementDefinition;
106 import org.openecomp.sdc.be.model.Resource;
107 import org.openecomp.sdc.be.model.Service;
108 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
109 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
110 import org.openecomp.sdc.be.model.UploadPropInfo;
111 import org.openecomp.sdc.be.model.UploadReqInfo;
112 import org.openecomp.sdc.be.model.UploadResourceInfo;
113 import org.openecomp.sdc.be.model.User;
114 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
115 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
116 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
117 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
118 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
119 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
120 import org.openecomp.sdc.be.servlets.AbstractValidationsServlet;
121 import org.openecomp.sdc.be.tosca.CsarUtils;
122 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
123 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
124 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
125 import org.openecomp.sdc.common.api.Constants;
126 import org.openecomp.sdc.common.zip.ZipUtils;
127 import org.openecomp.sdc.common.zip.exception.ZipException;
128 import org.openecomp.sdc.exception.ResponseFormat;
129 import org.yaml.snakeyaml.Yaml;
131 class ServiceImportBusinessLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
133 private static final String DEFAULT_ICON = "defaulticon";
135 private final ArtifactDefinition artifactDefinition = mock(ArtifactDefinition.class);
136 private final ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
137 private final ServletUtils servletUtils = mock(ServletUtils.class);
138 private final AbstractValidationsServlet servlet = new ArtifactExternalServlet(userBusinessLogic,
139 componentInstanceBusinessLogic, componentsUtils, servletUtils, resourceImportManager, artifactsBusinessLogic);
140 private final ApplicationDataTypeCache applicationDataTypeCache = mock(ApplicationDataTypeCache.class);
141 private final ArtifactTypeOperation artifactTypeOperation = mock(ArtifactTypeOperation.class);
142 private final DataTypeBusinessLogic dataTypeBusinessLogic = mock(DataTypeBusinessLogic.class);
143 private final ArtifactTypeImportManager artifactTypeImportManager = mock(ArtifactTypeImportManager.class);
144 private final GroupTypeOperation groupTypeOperation = mock(GroupTypeOperation.class);
147 private ServiceImportBusinessLogic sIBL;
149 public static String loadFileNameToJsonString(String fileName) throws IOException {
150 String sourceDir = "src/test/resources/normativeTypes";
151 return loadFileNameToJsonString(sourceDir, fileName);
154 private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
155 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
156 byte[] fileContent = Files.readAllBytes(filePath);
157 return new String(fileContent);
162 MockitoAnnotations.openMocks(this);
163 when(artifactDefinition.getMandatory()).thenReturn(true);
164 when(artifactDefinition.getArtifactName()).thenReturn("creatorFullName");
165 when(artifactDefinition.getArtifactType()).thenReturn("TOSCA_CSAR");
169 void testCreateService_OK() {
170 Service oldService = createServiceObject(true);
171 oldService.setComponentInstances(creatComponentInstances());
172 oldService.setComponentInstancesProperties(
173 Collections.singletonMap(COMPONENT_ID, Collections.singletonList(new ComponentInstanceProperty())));
174 String payloadName = "valid_vf";
175 Map<String, byte[]> payload = crateCsarFromPayload();
176 Service newService = createServiceObject(true);
177 newService.setComponentInstances(creatComponentInstances());
178 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
179 componentInstanceProperty.setName("propertiesName");
180 final JSONObject jsonObject = new JSONObject();
181 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), "zxjTestImportServiceAb_propertiesName");
182 componentInstanceProperty.setValue(jsonObject.toJSONString());
184 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
185 ArtifactDefinition artifactDef = new ArtifactDefinition();
186 String artifactUniqueId = "test_extcp_resource.assettoscatemplate";
187 artifactDef.setUniqueId(artifactUniqueId);
188 toscaArtifacts.put(ToscaExportHandler.ASSET_TOSCA_TEMPLATE, artifactDef);
189 Resource resource = new Resource();
190 String resourceUniqueId = "extcp_resource";
191 resource.setUniqueId(resourceUniqueId);
192 resource.setToscaArtifacts(toscaArtifacts);
193 ImmutablePair<String, byte[]> resourceTemplate = getNodeType();
194 String updatedNodeType = "org.openecomp.resource.cp.extCP";
196 newService.setComponentInstancesProperties(
197 Collections.singletonMap(COMPONENT_ID + "." + "zxjTestImportServiceAb", Collections.singletonList(componentInstanceProperty)));
198 newService.setProperties(getProperties());
200 when(serviceBusinessLogic.validateServiceBeforeCreate(eq(newService), any(User.class), any(AuditingActionEnum.class)))
201 .thenReturn(Either.left(newService));
202 when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
203 ServiceCsarInfo csarInfo = getCsarInfo();
204 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString())).thenReturn(csarInfo);
205 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
206 .thenReturn(Either.left(new HashMap<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>>()));
207 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), any(), any(Service.class)))
208 .thenReturn(getParsedToscaYamlInfo());
209 when(serviceBusinessLogic.lockComponentByName(newService.getSystemName(), oldService, CREATE_RESOURCE)).thenReturn(Either.left(true));
210 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
211 when(serviceImportParseLogic.createServiceTransaction(oldService, csarInfo.getModifier(), false)).thenReturn(newService);
212 when(serviceImportParseLogic.createInputsOnService(eq(oldService), anyMap())).thenReturn(newService);
213 Assertions.assertDoesNotThrow(() -> {
214 when(serviceImportParseLogic.createSubstitutionFilterOnService(eq(oldService), any())).thenReturn(newService);
216 when(serviceImportParseLogic.getNodeTypesFromTemplate(anyMap())).thenReturn(getNodeTypes());
217 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class), anyMap(), any(Service.class),
218 anyBoolean(), any(), anyList(), anyBoolean(), any(CsarInfo.class), anyBoolean())).thenReturn(
219 new ImmutablePair<>(new Resource(), ActionStatus.OK));
220 when(serviceImportParseLogic.getComponentWithInstancesFilter()).thenReturn(new ComponentParametersView());
221 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
222 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(new ComponentParametersView());
223 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
224 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
225 any(ComponentInstance.class), anyString())).thenReturn(Either.left(new RequirementDefinition()));
226 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class), any(ComponentInstance.class),
227 any(UploadReqInfo.class))).thenReturn(new CapabilityDefinition());
228 when(componentsUtils.getResponseFormat(eq(ActionStatus.OK), anyString())).thenReturn(new ResponseFormat(200));
229 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
230 doNothing().when(compositionBusinessLogic).setPositionsForComponentInstances(any(Service.class), anyString());
231 when(groupBusinessLogic.validateUpdateVfGroupNames(anyMap(), anyString())).thenReturn(Either.left(new HashMap<>()));
232 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean()))
233 .thenReturn(Either.left(newService));
234 when(serviceImportParseLogic.getServiceWithGroups(anyString())).thenReturn(newService);
235 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
236 when(graphLockOperation.unlockComponentByName(anyString(), anyString(), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
237 when(serviceImportParseLogic.createOutputsOnService(any(Service.class), any(), anyString())).thenReturn(newService);
238 when(toscaOperationFacade.updateInputsToComponent(anyList(), eq(newService.getUniqueId()))).thenReturn(Either.left(new ArrayList<>()));
240 when(applicationDataTypeCache.get(any(), contains("tosca.datatypes.test_"))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
241 DataTypeDefinition typeToBeUpdated = new DataTypeDefinition();
242 List<PropertyDefinition> properties = new ArrayList<>();
243 PropertyDefinition nameProperty = new PropertyDefinition();
244 nameProperty.setName("name");
245 nameProperty.setType("string");
246 properties.add(nameProperty);
247 PropertyDefinition versionProperty = new PropertyDefinition();
248 versionProperty.setName("version");
249 versionProperty.setType("string");
250 properties.add(versionProperty);
251 typeToBeUpdated.setProperties(properties);
252 when(applicationDataTypeCache.get(any(), eq("onap.datatypes.ToscaConceptIdentifier.datatype"))).thenReturn(Either.left(typeToBeUpdated));
253 when(applicationDataTypeCache.get(any(), matches("^((?!(tosca.datatypes.test_|onap.datatypes.ToscaConceptIdentifier)).)*$"))).thenReturn(Either.left(new DataTypeDefinition()));
255 when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.testartifacts.Name"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
256 when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.artifacts"))).thenReturn(Either.left(null));
257 when(toscaOperationFacade.getLatestByToscaResourceName(contains("org.openecomp.resource"), isNull()))
258 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
259 when(toscaOperationFacade.getLatestByToscaResourceName(contains("tosca.nodes."), isNull()))
260 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
261 when(toscaOperationFacade.getLatestByToscaResourceName(contains(updatedNodeType), isNull())).thenReturn(Either.left(resource));
262 when(artifactsBusinessLogic.handleDownloadRequestById(resourceUniqueId, artifactUniqueId, user.getUserId(), ComponentTypeEnum.RESOURCE, null, null))
263 .thenReturn(resourceTemplate);
264 when(toscaOperationFacade.updatePropertyOfComponent(eq(oldService), any(PropertyDefinition.class))).thenReturn(Either.left(null));
265 when(toscaOperationFacade.updateComponentInstancePropsToComponent(anyMap(), anyString())).thenReturn(Either.left(null));
266 when(groupTypeOperation.getGroupTypeByUid(anyString())).thenReturn(Either.left(new GroupTypeDefinition()));
268 Service result = sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
269 assertNotNull(result);
270 assertNotNull(result.getComponentInstances());
271 assertEquals(1, result.getComponentInstances().size());
272 assertNotNull(result.getComponentInstances().get(0));
273 assertNotNull(result.getComponentInstances().get(0).getCapabilities());
274 assertEquals(1, result.getComponentInstances().get(0).getCapabilities().size());
275 assertNotNull(result.getComponentInstances().get(0).getRequirements());
276 assertEquals(1, result.getComponentInstances().get(0).getRequirements().size());
277 assertNotNull(result.getCategories());
278 assertEquals(1, result.getCategories().size());
280 ArgumentCaptor<String> yaml = ArgumentCaptor.forClass(String.class);
281 verify(dataTypeBusinessLogic).createDataTypeFromYaml(yaml.capture(), isNull(), anyBoolean());
282 Map<String, Object> yamlMap = new Yaml().load(yaml.getValue());
283 assertEquals(3, yamlMap.size());
284 assertNotNull(yamlMap.get("tosca.datatypes.test_a"));
285 assertNotNull(yamlMap.get("tosca.datatypes.test_b"));
286 assertNotNull(yamlMap.get("onap.datatypes.ToscaConceptIdentifier"));
288 ArgumentCaptor<String> artifactTypes = ArgumentCaptor.forClass(String.class);
289 verify(artifactTypeImportManager).createArtifactTypes(artifactTypes.capture(),isNull(), anyBoolean());
290 Map<String, Object> artifactTypesMap = new Yaml().load(artifactTypes.getValue());
291 assertEquals(1, artifactTypesMap.size());
292 assertNotNull(artifactTypesMap.get("tosca.testartifacts.Name"));
294 ArgumentCaptor<Map<String, Object>> nodeTypes = ArgumentCaptor.forClass(Map.class);
295 verify(resourceImportManager).importAllNormativeResource(nodeTypes.capture(), any(), any(), any(),
296 anyBoolean(), anyBoolean());
297 Map<String, Object> nodeTypesMap = nodeTypes.getValue();
298 Map<String, Object> newUpdatedNodeType = (Map<String, Object>) nodeTypesMap.get(updatedNodeType);
299 assertEquals(8, ((Map<String, Object>) newUpdatedNodeType.get("properties")).size());
303 void testCreateService_Fail_NotFoundNodeTypesArtifacts() {
304 Service oldService = createServiceObject(true);
305 String payloadName = "valid_vf";
306 Map<String, byte[]> payload = crateCsarFromPayload();
307 Service newService = createServiceObject(true);
309 when(serviceBusinessLogic.validateServiceBeforeCreate(any(Service.class), any(User.class), any(AuditingActionEnum.class)))
310 .thenReturn(Either.left(newService));
311 when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
312 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString())).thenReturn(getCsarInfo());
313 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
314 .thenReturn(Either.right(ActionStatus.GENERAL_ERROR));
315 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), anyString(),
316 any(Service.class))).thenReturn(getParsedToscaYamlInfo());
318 Assertions.assertThrows(ComponentException.class,
319 () -> sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName));
323 void testCreateServiceFromCsar() {
324 Service oldService = createServiceObject(true);
325 String csarUUID = "valid_vf";
326 Map<String, byte[]> payload = crateCsarFromPayload();
327 ServiceCsarInfo csarInfo = getCsarInfo();
328 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> map =
331 when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class),
332 any(Map.class), anyString())).thenReturn(csarInfo);
333 when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class),
334 any(Service.class))).thenReturn(Either.left(map));
335 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromCsar(oldService,
336 user, payload, csarUUID));
340 void testCreateServiceFromYaml() {
341 Service oldService = createServiceObject(true);
342 Resource resource = createOldResource();
343 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
344 String yamlName = "group.yml";
345 ServiceCsarInfo csarInfo = getCsarInfo();
346 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
347 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
349 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
350 Map<String, Object> map = new HashMap<>();
351 map.put("tosca_definitions_version", "123");
352 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
353 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
354 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
355 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(Map.class),
356 eq(csarInfo), anyString(), any(Component.class))).thenReturn(parsedToscaYamlInfo);
357 when(serviceBusinessLogic.lockComponentByName(anyString(), any(Service.class), anyString()))
358 .thenReturn(Either.left(true));
360 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromYaml(oldService,
361 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
362 nodeTypesArtifactsToCreate, false, true, nodeName, user.getUserId()));
366 void testCreateServiceAndRIsFromYaml() {
367 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
368 Service oldService = createServiceObject(true);
369 Resource resource = createOldResource();
370 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
371 CreateServiceFromYamlParameter csfyp = getCsfyp();
372 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
373 Map<String, Object> map = new HashMap<>();
374 map.put("tosca_definitions_version", "123");
375 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
376 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
377 csfyp.setNodeTypesInfo(nodeTypesInfo);
378 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
379 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
380 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
381 false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId()));
385 void testCreateServiceAndRIsFromYamlShoudLook() {
386 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
387 Service oldService = createServiceObject(true);
388 Resource resource = createOldResource();
389 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
390 CreateServiceFromYamlParameter csfyp = getCsfyp();
391 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
392 Map<String, Object> map = new HashMap<>();
393 map.put("tosca_definitions_version", "123");
394 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
395 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
396 csfyp.setNodeTypesInfo(nodeTypesInfo);
397 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
398 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
399 Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
400 false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId()));
404 void testCreateOrUpdateArtifacts() {
405 ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
406 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
407 String yamlFileName = "group.yml";
408 CsarInfo csarInfo = getCsarInfo();
409 Resource preparedResource = createParseResourceObject(false);
410 preparedResource.setResourceType(ResourceTypeEnum.VF);
411 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
412 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
413 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
414 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
415 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
416 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
417 artifactDefinition.setArtifactName("artifactName");
418 artifactDefinitions.add(artifactDefinition);
419 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
420 artifactDefinitions);
421 nodeTypesArtifactsToHandle.put(nodeName, enumListEnumMap);
422 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
423 nodeTypeInfoToUpdateArtifacts.setNodeName(nodeName);
424 nodeTypeInfoToUpdateArtifacts.setNodeTypesArtifactsToHandle(nodeTypesArtifactsToHandle);
426 Assertions.assertNotNull(
427 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
428 preparedResource, nodeTypeInfoToUpdateArtifacts, true, true)
433 void testHandleVfCsarArtifacts() {
434 Resource resource = createParseResourceObject(true);
435 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
436 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
437 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
438 artifactDefinition.setUniqueId("uniqueId");
439 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
440 resource.setDeploymentArtifacts(deploymentArtifacts);
441 CsarInfo csarInfo = getCsarInfo();
442 Map<String, byte[]> csar = new HashMap<>();
443 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
444 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
445 csar.put(csarKey, artifactsMetaBytes);
446 csarInfo.setCsar(csar);
447 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
448 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
449 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
450 when(csarArtifactsAndGroupsBusinessLogic
451 .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
452 anyList())).thenReturn(Either.left(resource));
453 Assertions.assertNotNull(
454 sIBL.handleVfCsarArtifacts(resource,
455 csarInfo, createdArtifacts, artifactOperation, true, true));
459 void testHandleVfCsarArtifactsGetToscaElement() {
460 Resource resource = createParseResourceObject(true);
461 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
462 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
463 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
464 artifactDefinition.setUniqueId("uniqueId");
465 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
466 resource.setDeploymentArtifacts(deploymentArtifacts);
467 CsarInfo csarInfo = getCsarInfo();
468 Map<String, byte[]> csar = new HashMap<>();
469 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
470 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
471 csar.put(csarKey, artifactsMetaBytes);
472 csarInfo.setCsar(csar);
473 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
474 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
475 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
476 when(csarArtifactsAndGroupsBusinessLogic
477 .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
478 anyList())).thenReturn(Either.left(resource));
479 Assertions.assertNotNull(
480 sIBL.handleVfCsarArtifacts(resource,
481 csarInfo, createdArtifacts, artifactOperation, true, true));
485 void testCreateOrUpdateSingleNonMetaArtifactToComstants() {
486 Resource resource = createParseResourceObject(false);
487 CsarInfo csarInfo = getCsarInfo();
488 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
489 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
490 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
491 artifactDefinition.setArtifactName("artifactDefinition");
492 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
493 resource.setDeploymentArtifacts(deploymentArtifacts);
494 Assertions.assertNotNull(resource);
495 Assertions.assertNotNull(csarInfo);
496 sIBL.createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, true, true);
501 void testCreateOrUpdateNonMetaArtifacts() {
502 CsarInfo csarInfo = getCsarInfo();
503 Resource resource = createParseResourceObject(false);
504 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
505 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
507 Either<Resource, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo, resource,
508 createdArtifacts, true, true, artifactOperation);
509 assertEquals(result.left().value(), resource);
513 void testFindVfCsarArtifactsToHandle() {
514 Resource resource = createParseResourceObject(false);
515 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
516 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
517 artifactDefinition.setArtifactName("artifactDefinition");
518 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
519 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
520 artifacts.put("artifacts", artifactDefinition);
521 List<GroupDefinition> groups = new ArrayList<>();
522 GroupDefinition groupDefinition = new GroupDefinition();
523 groupDefinition.setUniqueId("groupDefinitionUniqueId");
524 groupDefinition.setName("groupDefinition");
525 groups.add(groupDefinition);
526 resource.setDeploymentArtifacts(deploymentArtifacts);
527 resource.setArtifacts(artifacts);
528 resource.setGroups(groups);
529 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
531 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
532 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(resource, artifactPathAndNameList, user);
533 assertNotNull(result.left().value());
537 void testOrganizeVfCsarArtifactsByArtifactOperation() {
538 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
539 artifactPathAndNameList.add(getNonMetaArtifactInfo());
540 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
541 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
542 artifactDefinition.setArtifactName("artifactName");
543 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
544 artifactDefinition.setArtifactChecksum("artifactChecksum");
545 existingArtifactsToHandle.add(artifactDefinition);
546 Resource resource = createParseResourceObject(false);
548 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
549 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
550 existingArtifactsToHandle,
552 assertNotNull(enumMapResponseFormatEither.left().value());
556 void testOrganizeVfCsarArtifactsByArtifactOperationElse() {
557 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
558 artifactPathAndNameList.add(getNonMetaArtifactInfo());
559 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
560 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
561 artifactDefinition.setArtifactName("artifactName");
562 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
563 artifactDefinition.setArtifactChecksum("artifactChecksum");
564 existingArtifactsToHandle.add(artifactDefinition);
565 Resource resource = createParseResourceObject(false);
566 Assertions.assertNotNull(
567 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource,
572 void testProcessCsarArtifacts() {
573 CsarInfo csarInfo = getCsarInfo();
574 Resource resource = createParseResourceObject(false);
575 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
576 Either<Resource, ResponseFormat> resStatus = Either.left(resource);
577 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
578 artifactPathAndNameList.add(getNonMetaArtifactInfo());
579 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
580 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
581 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactPathAndNameList);
582 Assertions.assertNotNull(
583 sIBL.processCsarArtifacts(csarInfo,
584 resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
588 void testCreateOrUpdateSingleNonMetaArtifact() {
589 Resource resource = createParseResourceObject(false);
590 CsarInfo csarInfo = getCsarInfo();
591 Map<String, byte[]> csar = csarInfo.getCsar();
592 String rootPath = System.getProperty("user.dir");
594 byte[] data = new byte[0];
595 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
597 data = Files.readAllBytes(path);
598 } catch (IOException e) {
601 csar.put("valid_vf.csar", data);
602 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
603 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
604 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
605 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
606 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
607 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
608 artifactDefinition.setArtifactName("artifactName");
609 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
610 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Resource.class), any(User.class),
611 any(Map.class), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
612 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
613 .thenReturn(Either.left(artifactDefinition));
614 Assertions.assertNotNull(
615 sIBL.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath,
616 artifactFileName, artifactType, artifactGroupType, artifactLabel,
617 artifactDisplayName, artifactDescription, artifactId, artifactOperation,
618 createdArtifacts, true, true, true));
622 void testCreateOrUpdateServiceArtifacts() throws IOException {
623 ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
624 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
625 String yamlFileName = "group.yml";
626 CsarInfo csarInfo = getCsarInfo();
627 Map<String, byte[]> csar = new HashMap<>();
628 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
629 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
630 csar.put(csarKey, artifactsMetaBytes);
631 csarInfo.setCsar(csar);
632 Service preparedService = createServiceObject(true);
633 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
634 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
635 artifactDefinition.setArtifactName("artifactDefinition");
636 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
637 preparedService.setDeploymentArtifacts(deploymentArtifacts);
638 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
639 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
640 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
642 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(createServiceObject(true)));
643 when(csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
644 anyString(), anyString(), anyList(), anyBoolean(), anyBoolean())).thenReturn(Either.left(preparedService));
645 Assertions.assertNotNull(
646 sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
647 preparedService, nodeTypeInfoToUpdateArtifacts, true, true));
651 void testHandleVfCsarServiceArtifacts() {
652 Service service = createServiceObject(true);
653 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
654 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
655 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
656 artifactDefinition.setUniqueId("uniqueId");
657 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
658 service.setDeploymentArtifacts(deploymentArtifacts);
659 CsarInfo csarInfo = getCsarInfo();
660 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
661 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
662 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
663 when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean())).thenReturn(
664 Either.left(service));
665 Assertions.assertNotNull(
666 sIBL.handleVfCsarArtifacts(service, csarInfo, createdArtifacts, artifactOperation, true, true));
670 void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
671 Service service = createServiceObject(true);
672 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
673 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
674 artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
675 artifactDefinition.setUniqueId("uniqueId");
676 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
677 service.setDeploymentArtifacts(deploymentArtifacts);
678 CsarInfo csarInfo = getCsarInfo();
679 Map<String, byte[]> csar = new HashMap<>();
680 String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
681 byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
682 csar.put(csarKey, artifactsMetaBytes);
683 csarInfo.setCsar(csar);
684 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
685 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
686 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
687 when(csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
688 anyString(), anyString(), anyList())).thenReturn(Either.left(service));
689 Assertions.assertNotNull(
690 sIBL.handleVfCsarArtifacts(service,
691 csarInfo, createdArtifacts, artifactOperation, true, true));
695 void testCreateOrUpdateNonMetaServiceArtifacts() {
696 CsarInfo csarInfo = getCsarInfo();
697 Service service = createServiceObject(true);
698 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
699 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
701 Either<Service, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo,
702 service, createdArtifacts, true, true, artifactOperation);
703 assertEquals(result.left().value(), service);
707 void testFindServiceCsarArtifactsToHandle() {
708 Service service = createServiceObject(true);
709 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
710 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
711 artifactDefinition.setArtifactName("artifactDefinition");
712 deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
713 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
714 artifacts.put("artifacts", artifactDefinition);
715 List<GroupDefinition> groups = new ArrayList<>();
716 GroupDefinition groupDefinition = new GroupDefinition();
717 groupDefinition.setUniqueId("groupDefinitionUniqueId");
718 groupDefinition.setName("groupDefinition");
719 groups.add(groupDefinition);
720 service.setDeploymentArtifacts(deploymentArtifacts);
721 service.setArtifacts(artifacts);
722 service.setGroups(groups);
723 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
725 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
726 ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
727 assertNotNull(result.left().value());
731 void testOrganizeVfCsarArtifactsByServiceArtifactOperation() {
732 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
733 artifactPathAndNameList.add(getNonMetaArtifactInfo());
734 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
735 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
736 artifactDefinition.setArtifactName("artifactName");
737 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
738 artifactDefinition.setArtifactChecksum("artifactChecksum");
739 existingArtifactsToHandle.add(artifactDefinition);
740 Service service = createServiceObject(true);
742 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
743 enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
744 existingArtifactsToHandle, service, user);
745 assertNotNull(enumMapResponseFormatEither.left().value());
749 void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse() {
750 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
751 artifactPathAndNameList.add(getNonMetaArtifactInfo());
752 List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
753 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
754 artifactDefinition.setArtifactName("artifactName");
755 artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
756 artifactDefinition.setArtifactChecksum("artifactChecksum");
757 existingArtifactsToHandle.add(artifactDefinition);
758 Service service = createServiceObject(true);
759 Assertions.assertNotNull(
760 sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user));
765 void testProcessServiceCsarArtifacts() {
766 CsarInfo csarInfo = getCsarInfo();
767 Service service = createServiceObject(true);
768 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
769 Either<Service, ResponseFormat> resStatus = Either.left(service);
770 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
771 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
772 List<CsarUtils.NonMetaArtifactInfo> objects = new ArrayList<>();
773 objects.add(getNonMetaArtifactInfo());
774 vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, objects);
775 Assertions.assertNotNull(
776 sIBL.processCsarArtifacts(csarInfo, service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
780 void testGetValidArtifactNames() {
781 CsarInfo csarInfo = getCsarInfo();
782 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
783 Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIBL.getValidArtifactNames(csarInfo,
784 collectedWarningMessages);
785 assertNotNull(result.left().value());
789 void testCreateOrUpdateSingleNonMetaServiceArtifact() {
790 Service service = createServiceObject(true);
791 CsarInfo csarInfo = getCsarInfo();
792 Map<String, byte[]> csar = csarInfo.getCsar();
793 String rootPath = System.getProperty("user.dir");
795 byte[] data = new byte[0];
796 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
798 data = Files.readAllBytes(path);
799 } catch (IOException e) {
802 csar.put("valid_vf.csar", data);
803 csarInfo.setCsar(csar);
804 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
805 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
806 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
807 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
808 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
809 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
810 artifactDefinition.setArtifactName("artifactName");
811 Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
812 when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Service.class), any(User.class),
813 anyMap(), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
814 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
815 .thenReturn(Either.left(artifactDefinition));
816 Assertions.assertNotNull(
817 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
818 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
819 artifactDescription, artifactId, artifactOperation, createdArtifacts,
824 void testCreateOrUpdateSingleNonMetaServiceArtifactNull() {
825 Service service = createServiceObject(true);
826 CsarInfo csarInfo = getCsarInfo();
827 String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
828 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
829 String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
830 ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
831 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
832 when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
833 .thenReturn(Either.left(artifactDefinition));
834 Assertions.assertNotNull(
835 sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
836 artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
837 artifactDescription, artifactId, artifactOperation, createdArtifacts,
842 void testCreateGroupsOnResource() {
843 Service service = createServiceObject(true);
844 Map<String, GroupDefinition> groups = new HashMap<>();
845 Assertions.assertNotNull(sIBL.createGroupsOnResource(service, groups));
849 void testCreateGroupsOnResourceNull() {
850 Service service = createServiceObject(true);
851 Map<String, GroupDefinition> groups = new HashMap<>();
852 Assertions.assertNotNull(
853 sIBL.createGroupsOnResource(service, groups));
857 void testUpdateGroupsMembersUsingResource() {
858 Service service = createServiceObject(true);
859 Map<String, GroupDefinition> groups = getGroups();
861 Assertions.assertNotNull(
862 sIBL.updateGroupsMembersUsingResource(groups, service));
866 void testUpdateGroupsMembersUsingResource_left() {
867 Service service = createServiceObject(true);
868 Map<String, GroupDefinition> groups = getGroups();
870 Assertions.assertNotNull(
871 sIBL.updateGroupsMembersUsingResource(groups, service));
875 void testCreateRIAndRelationsFromResourceYaml() throws IOException {
876 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
877 String yamlName = "group.yml";
878 Resource resource = createParseResourceObject(true);
879 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
880 String topologyTemplateYaml = getMainTemplateContent();
881 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
883 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
884 Map<String, Object> map = new HashMap<>();
885 map.put("tosca_definitions_version", "123");
886 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
888 CsarInfo csarInfo = getCsarInfo();
889 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
891 Assertions.assertThrows(ComponentException.class, () -> sIBL
892 .createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
893 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
894 csarInfo, nodeTypesArtifactsToCreate, nodeName));
898 void testCreateResourceInstancesRelations() {
899 String yamlName = "group.yml";
900 Resource resource = createParseResourceObject(true);
901 resource.setComponentInstances(creatComponentInstances());
902 resource.setResourceType(ResourceTypeEnum.VF);
903 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
904 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
905 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
906 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
907 Assertions.assertThrows(ComponentException.class, () -> sIBL
908 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
912 void testCreateResourceInstancesRelations_Empty() {
913 String yamlName = "group.yml";
914 Resource resource = createParseResourceObject(true);
915 resource.setComponentInstances(creatComponentInstances());
916 resource.setResourceType(ResourceTypeEnum.VF);
917 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
918 uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
919 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
920 when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
921 Assertions.assertThrows(ComponentException.class, () -> sIBL
922 .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
926 void testProcessComponentInstance1() {
927 String yamlName = "group.yml";
928 Resource resource = createParseResourceObject(true);
929 Resource originResource = createParseResourceObject(false);
930 originResource.setResourceType(ResourceTypeEnum.VF);
931 List<ComponentInstance> componentInstancesList = creatComponentInstances();
932 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
933 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
934 dataTypeDefinition.setName("dataTypeDefinitionName");
935 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
936 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
937 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
938 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
939 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
940 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
941 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
942 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
943 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
944 Map<String, Resource> originCompMap = new HashMap<>();
945 originCompMap.put("componentUid", originResource);
946 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
947 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
948 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
949 Assertions.assertNotNull(resource);
950 Assertions.assertNotNull(yamlName);
951 sIBL.processComponentInstance(yamlName, resource, componentInstancesList, allDataTypes.left().value(), instProperties,
952 instCapabilties, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes,
953 originCompMap, instInputs, instNodeFilter, null, uploadComponentInstanceInfo);
957 void testProcessComponentInstance_null() {
958 String yamlName = "group.yml";
959 Resource resource = createParseResourceObject(true);
960 Resource originResource = createParseResourceObject(false);
961 List<ComponentInstance> componentInstancesList = creatComponentInstances();
962 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
963 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
964 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
965 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
966 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
967 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
968 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
969 Map<String, Resource> originCompMap = new HashMap<>();
970 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
971 originCompMap.put("componentUid", originResource);
972 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
973 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
974 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
976 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
977 resource, componentInstancesList, null, instProperties, instCapabilties,
978 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
979 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
983 void testAddInputsValuesToRi() {
984 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
985 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
986 List<UploadPropInfo> uploadPropInfoList = getPropertyList();
987 properties.put("propertiesMap", uploadPropInfoList);
988 uploadComponentInstanceInfo.setProperties(properties);
989 Resource resource = createParseResourceObject(true);
990 Resource originResource = createParseResourceObject(false);
991 List<InputDefinition> inputs = new ArrayList<>();
992 InputDefinition inputDefinition = new InputDefinition();
993 inputDefinition.setName("inputDefinitionName");
994 inputDefinition.setUniqueId("uniqueId");
995 inputDefinition.setType("inputDefinitionType");
996 inputs.add(inputDefinition);
997 originResource.setInputs(inputs);
998 ComponentInstance currentCompInstance = new ComponentInstance();
999 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1000 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1001 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1002 dataTypeDefinition.setName("dataTypeDefinitionName");
1003 allDataTypes.put("dataTypeDefinitionMap", dataTypeDefinition);
1005 Assertions.assertThrows(ComponentException.class, () -> sIBL
1006 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1007 currentCompInstance, instInputs, allDataTypes));
1011 void testProcessProperty() {
1012 Resource resource = createParseResourceObject(true);
1013 List<InputDefinition> inputs = new ArrayList<>();
1014 InputDefinition inputDefinition = new InputDefinition();
1015 inputDefinition.setName("inputDefinitionName");
1016 inputDefinition.setUniqueId("uniqueId");
1017 inputDefinition.setType("inputDefinitionType");
1018 inputs.add(inputDefinition);
1019 resource.setInputs(inputs);
1020 ComponentInstance currentCompInstance = null;
1021 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1022 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1023 currPropertiesMap.put("propertyInfoName", inputDefinition);
1024 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1025 List<UploadPropInfo> propertyList = getPropertyList();
1026 Assertions.assertNotNull(resource);
1027 Assertions.assertNotNull(currPropertiesMap);
1028 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1032 void testHandleSubstitutionMappings() {
1033 Resource resource = createParseResourceObject(true);
1034 resource.setResourceType(ResourceTypeEnum.VF);
1035 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1036 when(toscaOperationFacade.getToscaFullElement(anyString()))
1037 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1039 Assertions.assertThrows(ComponentException.class,
1040 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1044 void testHandleSubstitutionMappings_left() {
1045 Resource resource = createParseResourceObject(true);
1046 resource.setResourceType(ResourceTypeEnum.VF);
1047 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1048 when(toscaOperationFacade.getToscaFullElement(anyString()))
1049 .thenReturn(Either.left(resource));
1051 Assertions.assertThrows(ComponentException.class,
1052 () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
1056 void testCreateResourceInstances() {
1057 String yamlName = "group.yml";
1058 Resource resource = createParseResourceObject(true);
1059 Resource originResource = createParseResourceObject(false);
1060 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1061 UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
1062 nodesInfoValue.setName("zxjTestImportServiceAb");
1063 nodesInfoValue.setRequirements(gerRequirements());
1064 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1065 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1066 nodeNamespaceMap.put("resources", originResource);
1068 Assertions.assertThrows(ComponentException.class,
1069 () -> sIBL.createResourceInstances(yamlName, resource, uploadResInstancesMap, nodeNamespaceMap));
1073 void testHandleNodeTypes() throws IOException {
1074 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1075 String yamlName = "group.yml";
1076 Resource resource = createParseResourceObject(true);
1077 String topologyTemplateYaml = getMainTemplateContent();
1078 boolean needLock = true;
1079 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1080 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1081 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1082 Map<String, Object> map = new HashMap<>();
1083 map.put("tosca_definitions_version", "123");
1084 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1085 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1086 CsarInfo csarInfo = getCsarInfo();
1087 Assertions.assertNotNull(resource);
1089 sIBL.handleNodeTypes(yamlName, resource, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1090 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
1094 void testHandleNestedVfc1() {
1095 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1096 Resource resource = createParseResourceObject(false);
1097 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1098 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1099 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1100 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1101 nodeTypeInfo.setTemplateFileName("groups.yml");
1102 nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
1103 nodesInfo.put(nodeName, nodeTypeInfo);
1104 CsarInfo csarInfo = getCsarInfo();
1106 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(resource,
1107 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1111 void testHandleComplexVfc1() {
1112 Resource resource = createParseResourceObject(true);
1113 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1114 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1115 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1116 CsarInfo csarInfo = getCsarInfo();
1117 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1118 String yamlName = "group.yml";
1119 when(serviceImportParseLogic.buildValidComplexVfc(any(Resource.class), any(CsarInfo.class), anyString(),
1120 anyMap())).thenReturn(createParseResourceObject(false));
1121 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1122 .thenReturn(Either.left(resource));
1123 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class),
1124 anyBoolean())).thenReturn(Either.left(true));
1126 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleComplexVfc(resource,
1127 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName));
1131 void testCreateNodeTypes1() {
1132 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1133 String yamlName = "group.yml";
1134 Resource resource = createParseResourceObject(false);
1135 boolean needLock = true;
1136 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1137 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
1138 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1139 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
1140 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1141 artifactDefinition.setArtifactName("artifactName");
1142 artifactDefinitions.add(artifactDefinition);
1143 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
1144 artifactDefinitions);
1145 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
1146 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1147 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1148 Map<String, Object> map = new HashMap<>();
1149 map.put("tosca_definitions_version", "123");
1150 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1151 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1153 CsarInfo csarInfo = getCsarInfo();
1154 Map<String, Object> mapToConvert = new HashMap<>();
1155 Map<String, Object> nodeTypes = new HashMap<>();
1156 nodeTypes.put(nodeName, "");
1157 Assertions.assertNotNull(resource);
1159 sIBL.createNodeTypes(yamlName,
1160 resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1161 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
1165 void testCreateNodeTypeResourceFromYaml() throws IOException {
1166 String yamlName = "group.yml";
1167 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1168 Map<String, Object> nodeMap = new HashMap<>();
1169 nodeMap.put(nodeName, getGroupsYaml());
1170 Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
1171 Map<String, Object> mapToConvert = new HashedMap();
1172 Resource resourceVf = createParseResourceObject(false);
1173 boolean needLock = true;
1174 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
1175 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1176 boolean forceCertificationAllowed = true;
1177 CsarInfo csarInfo = getCsarInfo();
1178 boolean isNested = true;
1179 UploadResourceInfo resourceMetaData = new UploadResourceInfo();
1180 resourceMetaData.setResourceType("VFC");
1181 ImmutablePair<Resource, ActionStatus> immutablePair = new ImmutablePair<>(resourceVf, ActionStatus.CREATED);
1182 when(serviceImportParseLogic.fillResourceMetadata(anyString(), any(Resource.class), anyString(), any(User.class)))
1183 .thenReturn(resourceMetaData);
1184 when(serviceImportParseLogic.buildNodeTypeYaml(any(Map.Entry.class), anyMap(), anyString(), any(CsarInfo.class)))
1185 .thenReturn(nodeName);
1186 when(serviceBusinessLogic.validateUser(any(User.class), anyString(), any(Component.class), any(AuditingActionEnum.class),
1187 anyBoolean())).thenReturn(user);
1188 when(serviceImportParseLogic.createResourceFromNodeType(anyString(), any(UploadResourceInfo.class), any(User.class), anyBoolean(),
1190 anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
1191 anyString(), anyBoolean())).thenReturn(immutablePair);
1192 Assertions.assertNotNull(
1193 sIBL.createNodeTypeResourceFromYaml(yamlName, nodeNameValue, user, mapToConvert,
1194 resourceVf, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1195 forceCertificationAllowed, csarInfo, isNested));
1199 void testCreateRIAndRelationsFromYaml() {
1200 String yamlName = "group.yml";
1201 Service service = createServiceObject(true);
1202 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
1203 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1205 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1206 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1207 CsarInfo csarInfo = getCsarInfo();
1208 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1209 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1211 Assertions.assertNotNull(sIBL
1212 .createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap,
1213 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1214 csarInfo, nodeTypesArtifactsToCreate, nodeName));
1218 void testCreateServiceInstancesRelations() {
1219 String yamlName = "group.yml";
1220 Service service = createServiceObject(true);
1221 service.setComponentInstances(creatComponentInstances());
1222 Resource newResource = createNewResource();
1223 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1224 ComponentParametersView componentParametersView = new ComponentParametersView();
1225 RequirementDefinition requirementDefinition = new RequirementDefinition();
1226 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1227 capabilityDefinition.setName("as");
1228 capabilityDefinition.setUniqueId("1");
1229 capabilityDefinition.setOwnerId("2");
1230 ResponseFormat responseFormat = new ResponseFormat();
1231 responseFormat.setStatus(200);
1232 when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(newResource);
1233 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1234 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(service));
1235 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1236 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1237 anyString())).thenReturn(Either.left(requirementDefinition));
1238 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1239 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1240 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1241 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
1242 Assertions.assertNotNull(sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap));
1246 void testCreateServiceInstancesRelations_Empty() {
1247 String yamlName = "group.yml";
1248 Service service = createServiceObject(true);
1249 service.setComponentInstances(creatComponentInstances());
1250 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1252 Assertions.assertThrows(ComponentException.class,
1253 () -> sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap));
1257 void testProcessComponentInstance() {
1258 String yamlName = "group.yml";
1259 Service service = createServiceObject(true);
1260 Resource originResource = createParseResourceObject(false);
1261 originResource.setResourceType(ResourceTypeEnum.VF);
1262 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1263 Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
1264 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
1265 dataTypeDefinition.setName("dataTypeDefinitionName");
1266 dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
1267 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
1268 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1269 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1270 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1271 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1272 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1273 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1274 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1275 Map<String, Resource> originCompMap = new HashMap<>();
1276 originCompMap.put("componentUid", originResource);
1277 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1278 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1279 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
1280 Assertions.assertNotNull(service);
1282 sIBL.processComponentInstance(yamlName, service, componentInstancesList, allDataTypes.left().value(),
1283 instProperties, instCapabilties, instRequirements, instDeploymentArtifacts,
1284 instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, null,
1285 uploadComponentInstanceInfo);
1289 void testProcessComponentInstance_null2() {
1290 String yamlName = "group.yml";
1291 Service service = createServiceObject(true);
1292 Resource originResource = createParseResourceObject(false);
1293 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1294 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1295 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1296 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1297 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1298 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1299 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1300 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1301 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1302 Map<String, Resource> originCompMap = new HashMap<>();
1303 originCompMap.put("componentUid", originResource);
1304 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1305 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1306 uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1308 Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
1309 service, componentInstancesList, null, instProperties, instCapabilties,
1310 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
1311 instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
1315 void testAddInputsValuesToRi2() {
1316 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1317 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1318 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
1319 UploadPropInfo uploadPropInfo = new UploadPropInfo();
1320 uploadPropInfo.setName("uploadPropInfo");
1321 uploadPropInfoList.add(uploadPropInfo);
1322 uploadPropInfoList.add(uploadPropInfo);
1323 properties.put("propertiesMap", uploadPropInfoList);
1324 uploadComponentInstanceInfo.setProperties(properties);
1325 Service resource = createServiceObject(true);
1326 Resource originResource = createParseResourceObject(false);
1327 List<InputDefinition> inputs = new ArrayList<>();
1328 InputDefinition inputDefinition = new InputDefinition();
1329 inputDefinition.setUniqueId("uniqueId");
1330 inputs.add(inputDefinition);
1331 originResource.setInputs(inputs);
1332 ComponentInstance currentCompInstance = new ComponentInstance();
1333 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1334 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1336 Assertions.assertThrows(ComponentException.class, () -> sIBL
1337 .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1338 currentCompInstance, instInputs, allDataTypes));
1342 void testProcessProperty2() {
1343 Service resource = createServiceObject(true);
1344 List<InputDefinition> inputs = new ArrayList<>();
1345 ComponentInstance currentCompInstance = null;
1346 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1347 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1348 InputDefinition inputDefinition = new InputDefinition();
1349 inputDefinition.setName("inputDefinitionName");
1350 inputDefinition.setType("inputDefinitionType");
1351 inputs.add(inputDefinition);
1352 currPropertiesMap.put("propertyInfoName", inputDefinition);
1353 resource.setInputs(inputs);
1354 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1355 List<UploadPropInfo> propertyList = new ArrayList<>();
1356 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1357 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1358 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1359 getInputValueDataDefinition.setInputName("inputDefinitionName");
1360 get_input.add(getInputValueDataDefinition);
1361 UploadPropInfo propertyInfo = new UploadPropInfo();
1362 propertyInfo.setValue("value");
1363 propertyInfo.setGet_input(get_input);
1364 propertyInfo.setName("propertyInfoName");
1365 propertyList.add(propertyInfo);
1366 Assertions.assertNotNull(resource);
1368 sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
1372 void testProcessGetInput() {
1373 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1374 List<InputDefinition> inputs = new ArrayList<>();
1375 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1377 Assertions.assertThrows(ComponentException.class, () -> sIBL.processGetInput(getInputValues, inputs, getInputIndex));
1381 void testProcessGetInput_optional() {
1382 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1383 List<InputDefinition> inputs = new ArrayList<>();
1384 InputDefinition inputDefinition = new InputDefinition();
1385 inputDefinition.setUniqueId("uniqueId");
1386 inputDefinition.setName("InputName");
1387 inputs.add(inputDefinition);
1388 GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1389 getInputIndex.setInputName("InputName");
1390 Assertions.assertNotNull(inputs);
1392 sIBL.processGetInput(getInputValues, inputs, getInputIndex);
1396 void testAddPropertyValuesToRi() {
1397 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1398 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1399 Resource resource = createParseResourceObject(true);
1400 List<InputDefinition> inputs = new ArrayList<>();
1401 InputDefinition inputDefinition = new InputDefinition();
1402 inputDefinition.setName("inputDefinitionName");
1403 inputDefinition.setUniqueId("uniqueId");
1404 inputDefinition.setType("inputDefinitionType");
1405 inputs.add(inputDefinition);
1406 resource.setInputs(inputs);
1407 Resource originResource = createParseResourceObject(false);
1408 originResource.setProperties(getProperties());
1409 ComponentInstance currentCompInstance = new ComponentInstance();
1410 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1411 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1412 ResponseFormat responseFormat = new ResponseFormat();
1413 when(serviceImportParseLogic.findInputByName(eq(inputs), any(GetInputValueDataDefinition.class)))
1414 .thenReturn(inputDefinition);
1415 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1416 Assertions.assertNotNull(
1417 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource,
1418 currentCompInstance, instProperties, allDataTypes));
1422 void testAddPropertyValuesToRi_else() {
1423 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1424 Resource resource = createParseResourceObject(true);
1425 Resource originResource = createParseResourceObject(false);
1426 originResource.setProperties(getProperties());
1427 ComponentInstance currentCompInstance = new ComponentInstance();
1428 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1429 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1430 ResponseFormat responseFormat = new ResponseFormat();
1431 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1432 Assertions.assertNotNull(
1433 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
1434 instProperties, allDataTypes));
1438 void testAddPropertyValuesToRi2() {
1439 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1440 uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1441 Service service = createServiceObject(true);
1442 List<InputDefinition> inputs = new ArrayList<>();
1443 InputDefinition inputDefinition = new InputDefinition();
1444 inputDefinition.setName("inputDefinitionName");
1445 inputDefinition.setUniqueId("uniqueId");
1446 inputDefinition.setType("inputDefinitionType");
1447 inputs.add(inputDefinition);
1448 service.setInputs(inputs);
1449 Resource originResource = createParseResourceObject(false);
1450 originResource.setProperties(getProperties());
1451 ComponentInstance currentCompInstance = new ComponentInstance();
1452 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1453 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1454 ResponseFormat responseFormat = new ResponseFormat();
1455 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1456 when(serviceImportParseLogic.findInputByName(anyList(), any(GetInputValueDataDefinition.class)))
1457 .thenReturn(inputDefinition);
1458 Assertions.assertNotNull(
1459 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource,
1460 currentCompInstance, instProperties, allDataTypes));
1464 void testAddPropertyValuesToRi2_else() {
1465 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1466 Service service = createServiceObject(true);
1467 Resource originResource = createParseResourceObject(false);
1468 originResource.setProperties(getProperties());
1469 ComponentInstance currentCompInstance = new ComponentInstance();
1470 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1471 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1472 ResponseFormat responseFormat = new ResponseFormat();
1473 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
1474 Assertions.assertNotNull(
1475 sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1476 instProperties, allDataTypes));
1480 void testProcessComponentInstanceCapabilities() {
1481 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1482 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1483 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1484 uploadComponentInstanceInfo.setCapabilities(getCapabilities());
1485 ComponentInstance currentCompInstance = new ComponentInstance();
1486 Resource originResource = createParseResourceObject(false);
1487 Assertions.assertNotNull(originResource);
1488 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1493 void testProcessComponentInstanceCapabilities_null() {
1494 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1495 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1496 UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1497 ComponentInstance currentCompInstance = new ComponentInstance();
1498 Resource originResource = createParseResourceObject(false);
1499 Assertions.assertNotNull(originResource);
1501 sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
1506 void testUpdateCapabilityPropertiesValues() {
1507 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1508 Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1509 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1510 Assertions.assertNull(allDataTypes);
1511 sIBL.updateCapabilityPropertiesValues(null, originCapabilities, newPropertiesMap);
1515 void testUpdatePropertyValues() {
1516 List<ComponentInstanceProperty> properties = new ArrayList<>();
1517 Map<String, UploadPropInfo> newProperties = new HashMap<>();
1518 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1519 Assertions.assertNotNull(allDataTypes);
1520 sIBL.updatePropertyValues(properties, newProperties, allDataTypes);
1524 void testUpdatePropertyValue() {
1525 ComponentInstanceProperty property = new ComponentInstanceProperty();
1526 property.setType("services");
1527 UploadPropInfo propertyInfo = new UploadPropInfo();
1528 propertyInfo.setValue("value");
1529 Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1530 when(serviceBusinessLogic.validatePropValueBeforeCreate(any(IPropertyInputCommon.class), anyString(), anyBoolean(), anyMap())).thenReturn(
1532 Assertions.assertNotNull(sIBL.updatePropertyValue(property, propertyInfo, allDataTypes));
1536 void testGetOriginResource() {
1537 String yamlName = "group.yml";
1538 Map<String, Resource> originCompMap = new HashMap<>();
1539 ComponentInstance currentCompInstance = new ComponentInstance();
1540 currentCompInstance.setComponentUid("currentCompInstance");
1541 when(toscaOperationFacade.getToscaFullElement(anyString()))
1542 .thenReturn(Either.left(createParseResourceObject(true)));
1543 Assertions.assertNotNull(sIBL.getOriginResource(yamlName, originCompMap, currentCompInstance));
1547 void testUpdateCalculatedCapReqWithSubstitutionMappings() {
1548 Resource resource = createParseResourceObject(false);
1549 resource.setComponentInstances(creatComponentInstances());
1550 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1552 when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
1553 Assertions.assertNotNull(sIBL.updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap));
1557 void testFillUpdatedInstCapabilitiesRequirements() {
1558 List<ComponentInstance> componentInstances = creatComponentInstances();
1559 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1560 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1561 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
1562 Assertions.assertNotNull(componentInstances);
1564 sIBL.fillUpdatedInstCapabilitiesRequirements(componentInstances, uploadResInstancesMap,
1565 updatedInstCapabilities, updatedInstRequirement);
1569 void testFillUpdatedInstCapabilities() {
1570 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
1571 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1572 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1573 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1574 capabilityDefinition.setName("mme_ipu_vdu.feature");
1575 capabilityDefinitionList.add(capabilityDefinition);
1576 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
1577 ComponentInstance instance = new ComponentInstance();
1578 instance.setCapabilities(capabilities);
1579 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1580 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
1581 Assertions.assertNotNull(instance);
1583 sIBL.fillUpdatedInstCapabilities(updatedInstCapabilties, instance, capabilitiesNamesToUpdate);
1587 void testFillUpdatedInstRequirements() {
1588 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
1590 ComponentInstance instance = new ComponentInstance();
1591 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1592 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1593 RequirementDefinition requirementDefinition = new RequirementDefinition();
1594 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1595 requirementDefinitionList.add(requirementDefinition);
1596 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
1597 instance.setRequirements(requirements);
1598 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1599 requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
1600 "requirementsNamesToUpdate");
1601 Assertions.assertNotNull(instance);
1603 sIBL.fillUpdatedInstRequirements(updatedInstRequirements, instance, requirementsNamesToUpdate);
1607 void testAddRelationsToRI() {
1608 String yamlName = "group.yml";
1609 Service service = createServiceObject(true);
1611 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1612 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1613 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1614 List<ComponentInstance> componentInstancesList = creatComponentInstances();
1615 ComponentInstance componentInstance = new ComponentInstance();
1616 componentInstance.setName("zxjTestImportServiceAb");
1617 componentInstancesList.add(componentInstance);
1618 service.setComponentInstances(componentInstancesList);
1619 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1620 RequirementDefinition requirementDefinition = new RequirementDefinition();
1621 requirementDefinition.setOwnerId("1");
1622 requirementDefinition.setUniqueId("2");
1623 requirementDefinition.setCapability("3");
1624 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1625 capabilityDefinition.setName("4");
1626 capabilityDefinition.setUniqueId("5");
1627 capabilityDefinition.setOwnerId("6");
1628 ResponseFormat responseFormat = new ResponseFormat();
1629 responseFormat.setStatus(200);
1630 when(serviceImportParseLogic.findAvailableRequirement(anyString(),
1631 anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
1632 anyString())).thenReturn(Either.left(requirementDefinition));
1633 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1634 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1635 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1636 Assertions.assertNotNull(service);
1638 sIBL.addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1642 void testAddRelationsToRI_null() {
1643 String yamlName = "group.yml";
1644 Service service = createServiceObject(true);
1645 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1646 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1647 uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1648 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1649 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1651 Assertions.assertThrows(ComponentException.class, () -> sIBL.addRelationsToRI(yamlName,
1652 service, uploadResInstancesMap, componentInstancesList, relations));
1656 void testAddRelationToRI() {
1657 String yamlName = "group.yml";
1658 Service service = createServiceObject(true);
1659 service.setComponentInstances(creatComponentInstances());
1661 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1662 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1663 RequirementDefinition requirementDefinition = new RequirementDefinition();
1664 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1665 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1666 capabilityDefinition.setName("capabilityDefinitionName");
1667 capabilityDefinition.setUniqueId("capabilityDefinitionUniqueId");
1668 capabilityDefinition.setOwnerId("capabilityDefinitionOwnerId");
1669 ResponseFormat responseFormat = new ResponseFormat();
1670 when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
1671 any(ComponentInstance.class), anyString())).thenReturn(Either.left(requirementDefinition));
1672 when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
1673 any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
1674 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1675 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1676 Assertions.assertNotNull(relations.get(0).getRelationships().get(0).getOperations());
1680 void testAddRelationToRI_null() {
1681 String yamlName = "group.yml";
1682 Service service = createServiceObject(true);
1683 List<ComponentInstance> componentInstancesList = new ArrayList<>();
1684 service.setComponentInstances(componentInstancesList);
1685 ResponseFormat responseFormat = new ResponseFormat();
1686 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1687 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1688 when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
1689 Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
1693 void testGetResourceAfterCreateRelations() {
1694 Service service = createServiceObject(true);
1695 ComponentParametersView componentParametersView = createComponentParametersView();
1696 when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1697 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1698 .thenReturn(Either.left(createServiceObject(true)));
1699 Assertions.assertNotNull(sIBL.getResourceAfterCreateRelations(service));
1703 void testCreateServiceInstances() {
1704 String yamlName = "group.yml";
1705 Service service = createServiceObject(true);
1706 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1707 UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1708 uploadResInstancesMap.put("uploadResInstancesMap", nodesInfoValue);
1709 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1710 Resource resource = createParseResourceObject(true);
1711 resource.setToscaResourceName("toscaResourceName");
1712 nodeNamespaceMap.put("nodeNamespaceMap", resource);
1714 Assertions.assertThrows(ComponentException.class,
1715 () -> sIBL.createServiceInstances(yamlName, service, uploadResInstancesMap, nodeNamespaceMap));
1719 void testCreateAndAddResourceInstance() {
1720 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1721 String yamlName = "group.yml";
1722 Resource resource = createParseResourceObject(false);
1723 Resource originResource = createParseResourceObject(true);
1724 originResource.setResourceType(ResourceTypeEnum.VF);
1725 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1726 nodeNamespaceMap.put("resources", originResource);
1727 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1728 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1730 Assertions.assertThrows(ComponentException.class, () -> sIBL
1731 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, resource,
1732 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1736 void testCreateAndAddResourceInstances() {
1737 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1738 String yamlName = "group.yml";
1739 Service service = createServiceObject(true);
1740 service.setServiceType("services");
1741 Resource originResource = createParseResourceObject(true);
1742 originResource.setResourceType(ResourceTypeEnum.VF);
1743 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1744 nodeNamespaceMap.put("resources", originResource);
1745 Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1746 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1748 Assertions.assertThrows(ComponentException.class, () -> sIBL
1749 .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service,
1750 nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
1754 void testValidateResourceInstanceBeforeCreate() {
1755 String yamlName = "group.yml";
1756 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
1757 Resource originResource = createParseResourceObject(true);
1758 ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
1759 componentMetadataDataDefinition.setState(LifecycleStateEnum.CERTIFIED.name());
1760 ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
1761 originResource.setComponentMetadataDefinition(componentMetadataDefinition);
1762 originResource.setComponentType(ComponentTypeEnum.RESOURCE);
1763 originResource.setToscaResourceName("toscaResourceName");
1764 originResource.setResourceType(ResourceTypeEnum.VF);
1765 originResource.setResourceType(ResourceTypeEnum.VF);
1766 Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1767 nodeNamespaceMap.put("resources", originResource);
1768 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(originResource));
1769 Assertions.assertNotNull(
1770 sIBL.validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, nodeNamespaceMap));
1774 void testHandleServiceNodeTypes() {
1775 String yamlName = "group.yml";
1776 Service service = createServiceObject(true);
1777 String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
1779 boolean needLock = true;
1780 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1781 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1782 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1783 CsarInfo csarInfo = getCsarInfo();
1784 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1785 when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
1786 Assertions.assertNotNull(service);
1788 sIBL.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
1789 nodeTypesNewCreatedArtifacts,
1790 nodeTypesInfo, csarInfo, nodeName);
1794 void testValidateResourceNotExisted() {
1795 String type = "org.openecomp.resource.vf";
1797 Assertions.assertThrows(ComponentException.class, () -> sIBL.validateResourceNotExisted(type));
1801 void testHandleNestedVF() {
1802 Service service = createServiceObject(true);
1803 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1804 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1805 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1806 CsarInfo csarInfo = getCsarInfo();
1807 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1809 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVF(service,
1810 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1814 void testHandleNestedVfc() {
1815 Service service = createServiceObject(true);
1816 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1817 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1818 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1819 CsarInfo csarInfo = getCsarInfo();
1820 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1822 Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(service,
1823 nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
1827 void testHandleComplexVfc() {
1828 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1829 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1830 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1831 CsarInfo csarInfo = getCsarInfo();
1832 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1833 String yamlName = "group.yml";
1834 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1835 .thenReturn(createNewResource());
1836 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1837 .thenReturn(Either.left(createNewResource()));
1838 when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class), anyBoolean()))
1839 .thenReturn(Either.left(true));
1841 Assertions.assertThrows(ComponentException.class, () -> sIBL
1842 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1843 csarInfo, nodeName, yamlName));
1847 void testHandleComplexVfcStatus() {
1848 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1849 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1850 Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1851 CsarInfo csarInfo = getCsarInfo();
1852 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1853 String yamlName = "group.yml";
1854 when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
1855 .thenReturn(createNewResource());
1856 when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1857 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1859 Assertions.assertThrows(ComponentException.class, () -> sIBL
1860 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1861 csarInfo, nodeName, yamlName));
1865 void testHandleComplexVfc2() {
1866 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1867 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1868 Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1869 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1870 String yamlName = "group.yml";
1871 CsarInfo csarInfo = getCsarInfo();
1872 Map<String, byte[]> csar = new HashMap<>();
1873 csar.put(yamlName, yamlName.getBytes());
1874 csarInfo.setCsar(csar);
1875 Resource oldComplexVfc = createParseResourceObject(false);
1876 Resource newComplexVfc = createParseResourceObject(true);
1878 Assertions.assertThrows(ComponentException.class, () -> sIBL
1879 .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
1880 csarInfo, nodeName, yamlName, oldComplexVfc, newComplexVfc));
1884 void testUpdateResourceFromYaml() throws IOException {
1885 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1886 Resource newResource = createNewResource();
1887 Resource oldResource = createOldResource();
1888 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1889 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1890 String yamlFileName = "group.yml";
1891 String yamlFileContent = getYamlFileContent();
1892 CsarInfo csarInfo = getCsarInfo();
1893 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1894 Map<String, Object> map = new HashMap<>();
1895 map.put("tosca_definitions_version", "123");
1896 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1897 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1898 boolean isNested = true;
1900 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1901 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1902 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
1903 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
1904 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
1905 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
1906 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
1907 .thenReturn(Either.left(newResource));
1908 Assertions.assertThrows(ComponentException.class, () -> sIBL
1909 .updateResourceFromYaml(oldResource, newResource, actionEnum, createdArtifacts,
1910 yamlFileName, yamlFileContent, csarInfo, nodeTypesInfo,
1911 nodeTypesArtifactsToHandle, nodeName, isNested));
1915 void testCreateResourceFromYaml() throws IOException {
1916 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1917 Resource resource = createParseResourceObject(true);
1918 String topologyTemplateYaml = getMainTemplateContent();
1919 String yamlName = "group.yml";
1921 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1922 Map<String, Object> map = new HashMap<>();
1923 map.put("tosca_definitions_version", "123");
1924 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1926 CsarInfo csarInfo = getCsarInfo();
1927 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1928 boolean shouldLock = false;
1929 boolean inTransaction = true;
1931 when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
1932 anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
1933 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Component.class))).thenReturn(resource);
1934 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
1935 .thenReturn(Either.left(false));
1936 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
1937 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceFromYaml(resource,
1938 topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
1939 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
1943 void testCreateResourceAndRIsFromYaml() throws IOException {
1944 String yamlName = "group.yml";
1945 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1946 Resource resource = createParseResourceObject(true);
1947 resource.setSystemName("SystemName");
1948 resource.setComponentType(ComponentTypeEnum.RESOURCE);
1949 AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1950 boolean isNormative = true;
1951 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1952 String topologyTemplateYaml = getMainTemplateContent();
1953 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1954 Map<String, Object> map = new HashMap<>();
1955 map.put("tosca_definitions_version", "123");
1956 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
1957 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
1959 CsarInfo csarInfo = getCsarInfo();
1960 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1961 boolean shouldLock = false;
1962 boolean inTransaction = true;
1963 when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Resource.class)))
1964 .thenReturn(resource);
1966 when(serviceBusinessLogic.lockComponentByName(anyString(), any(), anyString()))
1967 .thenReturn(Either.left(true));
1969 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
1970 .thenReturn(Either.left(false));
1972 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
1974 Assertions.assertThrows(ComponentException.class, () -> sIBL
1975 .createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, actionEnum,
1976 isNormative, createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo,
1977 nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
1981 void testCreateGroupsOnResource2() {
1982 Resource resource = createParseResourceObject(false);
1983 Map<String, GroupDefinition> groups = null;
1984 List<GroupDefinition> groupDefinitionList = new ArrayList<>();
1985 GroupDefinition groupDefinition = new GroupDefinition();
1986 groupDefinition.setUniqueId("groupDefinitionUniqueId");
1987 groupDefinition.setName("groupDefinition");
1988 groupDefinitionList.add(groupDefinition);
1990 Assertions.assertNotNull(
1991 sIBL.createGroupsOnResource(resource, groups));
1995 void testCreateGroupsOnResource2_null() {
1996 Resource resource = createParseResourceObject(false);
1997 Map<String, GroupDefinition> groups = null;
1999 Either<Resource, ResponseFormat> result = sIBL.createGroupsOnResource(resource, groups);
2000 assertEquals(result.left().value(), resource);
2004 void testUpdateGroupsMembersUsingResource2() {
2005 Resource resource = createParseResourceObject(true);
2006 Map<String, GroupDefinition> groups = getGroups();
2008 Assertions.assertNotNull(
2009 sIBL.updateGroupsMembersUsingResource(groups, resource));
2013 void testUpdateGroupsMembersUsingResource_left2() {
2014 Resource resource = createParseResourceObject(true);
2015 Map<String, GroupDefinition> groups = getGroups();
2017 Assertions.assertNotNull(
2018 sIBL.updateGroupsMembersUsingResource(groups, resource));
2022 void testUpdateGroupMembers() throws IOException {
2023 Map<String, GroupDefinition> groups = new HashMap<>();
2024 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2025 Resource component = createParseResourceObject(true);
2026 List<ComponentInstance> componentInstances = creatComponentInstances();
2027 String groupName = "tosca_simple_yaml_1_1";
2028 Map<String, String> members = new HashMap<>();
2029 members.put("zxjTestImportServiceAb", getGroupsYaml());
2030 Assertions.assertNotNull(component);
2032 sIBL.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2036 void testUpdateGroupMembers_null() throws IOException {
2037 Map<String, GroupDefinition> groups = new HashMap<>();
2038 GroupDefinition updatedGroupDefinition = new GroupDefinition();
2039 Resource component = createParseResourceObject(true);
2040 List<ComponentInstance> componentInstances = new ArrayList<>();
2041 String groupName = "tosca_simple_yaml_1_1";
2042 Map<String, String> members = new HashMap<>();
2043 members.put("zxjTestImportServiceAb", getGroupsYaml());
2045 Assertions.assertThrows(ComponentException.class, () -> sIBL.updateGroupMembers(groups,
2046 updatedGroupDefinition, component, componentInstances, groupName, members));
2050 void setCreateResourceTransaction() {
2051 Resource resource = createParseResourceObject(false);
2052 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2053 boolean isNormative = true;
2054 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
2055 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
2057 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2061 void setCreateResourceTransaction_leftTrue() {
2062 Resource resource = createParseResourceObject(false);
2063 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2064 boolean isNormative = true;
2065 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(true));
2067 Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
2071 void setCreateResourceTransaction_Left() {
2072 Resource resource = createParseResourceObject(false);
2073 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2074 when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(false));
2075 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
2076 Assertions.assertNotNull(sIBL.createResourceTransaction(resource, user, false));
2080 void testUpdateExistingResourceByImport() {
2081 Resource newResource = createNewResource();
2082 Resource oldResource = createOldResource();
2083 when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
2084 any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
2085 when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
2086 any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
2087 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
2088 .thenReturn(Either.left(newResource));
2089 Assertions.assertNotNull(sIBL.updateExistingResourceByImport(newResource, oldResource, user, true, false, true));
2093 void testCreateNewResourceToOldResource() {
2094 Resource newResource = createNewResource();
2095 Resource oldResource = createOldResource();
2097 sIBL.createNewResourceToOldResource(newResource, oldResource, user);
2098 assertEquals(newResource.getSystemName(), oldResource.getSystemName());
2102 void testCreateResourcesFromYamlNodeTypesList() {
2103 String yamlName = "group.yml";
2104 Service service = createServiceObject(true);
2105 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2106 boolean needLock = true;
2107 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2108 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2109 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2110 CsarInfo csarInfo = getCsarInfo();
2112 Assertions.assertThrows(ComponentException.class, () -> sIBL
2113 .createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock,
2114 nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo));
2118 void testCreateNodeTypes() {
2119 String yamlName = "group.yml";
2120 Service service = createServiceObject(true);
2121 boolean needLock = true;
2122 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2123 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2124 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2125 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2126 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2127 artifactDefinition.setArtifactName("artifactName");
2128 artifactDefinitions.add(artifactDefinition);
2129 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2130 artifactDefinitions);
2131 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2132 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2133 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2134 CsarInfo csarInfo = getCsarInfo();
2135 Map<String, Object> mapToConvert = new HashMap<>();
2136 Map<String, Object> nodeTypes = new HashMap<>();
2137 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2138 nodeTypesInfo.put("nodeTyp", nodeTypeInfo);
2139 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2142 Assertions.assertThrows(ComponentException.class, () -> sIBL.createNodeTypes(yamlName,
2143 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2144 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes));
2148 void testCreateNodeTypesElse() {
2149 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2150 String yamlName = "group.yml";
2151 Service service = createServiceObject(true);
2152 boolean needLock = true;
2153 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2154 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2155 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2156 List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2157 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2158 artifactDefinition.setArtifactName("artifactName");
2159 artifactDefinitions.add(artifactDefinition);
2160 enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2161 artifactDefinitions);
2162 nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
2163 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2164 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2165 Map<String, Object> map = new HashMap<>();
2166 map.put("tosca_definitions_version", "123");
2167 nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
2168 ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
2170 CsarInfo csarInfo = getCsarInfo();
2171 Map<String, Object> mapToConvert = new HashMap<>();
2172 Map<String, Object> nodeTypes = new HashMap<>();
2173 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2174 nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2176 when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class),
2177 anyMap(), any(Service.class), anyBoolean(), anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
2178 anyBoolean())).thenReturn(getResourceCreated());
2179 Assertions.assertNotNull(service);
2181 sIBL.createNodeTypes(yamlName,
2182 service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
2183 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
2186 protected ImmutablePair<Resource, ActionStatus> getResourceCreated() {
2187 Resource resource = createOldResource();
2188 ImmutablePair<Resource, ActionStatus> resourceCreated = new ImmutablePair<>(resource, ActionStatus.OK);
2190 return resourceCreated;
2193 protected Resource createNewResource() {
2194 Resource newResource = createParseResourceObject(false);
2195 newResource.setVersion("1.0");
2196 newResource.setInvariantUUID("");
2197 newResource.setLifecycleState(null);
2198 newResource.setUUID("");
2199 newResource.setNormalizedName("");
2200 newResource.setSystemName("");
2201 newResource.setCsarUUID("");
2202 newResource.setImportedToscaChecksum("");
2203 newResource.setDerivedFromGenericType("");
2204 newResource.setDerivedFromGenericVersion("");
2205 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2206 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2207 artifactDefinition.setArtifactName("artifactDefinition");
2208 toscaArtifacts.put("toscaArtifactsMap", artifactDefinition);
2209 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2210 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2211 interfaceDefinition.setOwnerId("OwnerId");
2212 interfaces.put("interfacesMap", interfaceDefinition);
2213 newResource.setInterfaces(interfaces);
2214 newResource.setToscaArtifacts(toscaArtifacts);
2215 newResource.setProperties(getProperties());
2219 protected Resource createOldResource() {
2220 Resource newResource = createParseResourceObject(false);
2221 newResource.setVersion("1.0");
2222 newResource.setUniqueId("ResourceUniqueId");
2223 newResource.setInvariantUUID("552e8f6c-340c-4fb4-8a82-fe7732fd8010");
2224 newResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
2225 newResource.setUUID("13065b80-ca96-4331-b643-d28aeaf961cb");
2226 newResource.setNormalizedName("NormalizedName");
2227 newResource.setSystemName("default");
2228 newResource.setCsarUUID("CsarUUID");
2229 newResource.setImportedToscaChecksum("ImportedToscaChecksum");
2230 newResource.setDerivedFromGenericType("DerivedFromGenericType");
2231 newResource.setDerivedFromGenericVersion("0.1");
2232 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2233 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2234 artifactDefinition.setArtifactName("tosca_simple_yaml_1_1");
2235 toscaArtifacts.put("tosca_definitions_version", artifactDefinition);
2236 Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2237 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2238 interfaceDefinition.setDescription("Invoked upon receipt of an Instantiate VNF request");
2239 interfaces.put("tosca_simple_yaml_1_1", interfaceDefinition);
2240 newResource.setInterfaces(interfaces);
2241 newResource.setToscaArtifacts(toscaArtifacts);
2242 List<PropertyDefinition> properties = new ArrayList<>();
2243 PropertyDefinition propertyDefinition = new PropertyDefinition();
2244 propertyDefinition.setName("tosca_simple_yaml_1_1");
2245 properties.add(propertyDefinition);
2246 newResource.setProperties(properties);
2250 protected Map<String, InputDefinition> getCurrPropertiesMap() {
2251 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2252 InputDefinition inputDefinition = new InputDefinition();
2253 inputDefinition.setName("inputDefinitionName");
2254 inputDefinition.setUniqueId("uniqueId");
2255 inputDefinition.setType("inputDefinitionType");
2256 currPropertiesMap.put("propertyInfoName", inputDefinition);
2257 return currPropertiesMap;
2260 protected List<UploadPropInfo> getPropertyList() {
2261 List<UploadPropInfo> propertyList = new ArrayList<>();
2262 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2263 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2264 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2265 getInputValueDataDefinition.setInputName("inputDefinitionName");
2266 get_input.add(getInputValueDataDefinition);
2267 UploadPropInfo propertyInfo = new UploadPropInfo();
2268 propertyInfo.setValue("value");
2269 propertyInfo.setGet_input(get_input);
2270 propertyInfo.setName("propertyInfoName");
2271 propertyList.add(propertyInfo);
2272 return propertyList;
2275 private Map<String, NodeTypeInfo> getNodeTypesInfo() {
2276 Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2277 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2278 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2279 nodeTypeInfo.setNested(true);
2280 nodeTypeInfo.setTemplateFileName("templateFileName");
2281 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2282 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2283 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2284 return nodeTypesInfo;
2287 private Map<String, Object> getNodeTypes() {
2288 Map<String, Object> nodeTypesInfo = new HashMap<>();
2289 NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2290 Map<String, Object> mappedToscaTemplate = new HashMap<>();
2291 nodeTypeInfo.setNested(true);
2292 nodeTypeInfo.setTemplateFileName("templateFileName");
2293 nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2294 String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2295 nodeTypesInfo.put(nodeName, nodeTypeInfo);
2296 return nodeTypesInfo;
2299 private Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap() {
2300 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
2301 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2302 Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
2303 capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2304 Map<String, String> requirementsNamesToUpdate = new HashMap<>();
2305 requirementsNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
2306 uploadResInstancesMap.put("zxjTestImportServiceAb", uploadComponentInstanceInfo);
2307 return uploadResInstancesMap;
2310 protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties() {
2311 Map<String, List<UploadPropInfo>> properties = new HashMap<>();
2312 List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
2313 UploadPropInfo uploadPropInfo = new UploadPropInfo();
2314 List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2315 GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2316 getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2317 get_input.add(getInputValueDataDefinition);
2318 uploadPropInfo.setName("propertiesName");
2319 uploadPropInfo.setValue("value");
2320 uploadPropInfo.setGet_input(get_input);
2321 uploadPropInfoList.add(uploadPropInfo);
2322 properties.put("uploadComponentInstanceInfo", uploadPropInfoList);
2326 protected List<PropertyDefinition> getProperties() {
2327 List<PropertyDefinition> properties = new ArrayList<>();
2328 PropertyDefinition propertyDefinition = new PropertyDefinition();
2329 propertyDefinition.setName("propertiesName");
2330 properties.add(propertyDefinition);
2334 protected Map<String, List<UploadReqInfo>> gerRequirements() {
2335 Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
2336 String requirementName = "tosca.capabilities.Node";
2337 List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
2338 UploadReqInfo uploadReqInfo = new UploadReqInfo();
2339 uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
2340 uploadReqInfoMap.put(requirementName, uploadReqInfoList);
2341 return uploadReqInfoMap;
2344 protected ComponentParametersView createComponentParametersView() {
2345 ComponentParametersView parametersView = new ComponentParametersView();
2346 parametersView.disableAll();
2347 parametersView.setIgnoreComponentInstances(false);
2348 parametersView.setIgnoreComponentInstancesProperties(false);
2349 parametersView.setIgnoreCapabilities(false);
2350 parametersView.setIgnoreRequirements(false);
2351 parametersView.setIgnoreGroups(false);
2352 return parametersView;
2355 protected Map<String, byte[]> crateCsarFromPayload() {
2356 String payloadName = "valid_vf.csar";
2357 String rootPath = System.getProperty("user.dir");
2361 Map<String, byte[]> returnValue = null;
2363 path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2364 data = Files.readAllBytes(path);
2365 payloadData = Base64.encodeBase64String(data);
2366 UploadResourceInfo resourceInfo = new UploadResourceInfo();
2367 resourceInfo.setPayloadName(payloadName);
2368 resourceInfo.setPayloadData(payloadData);
2369 Method privateMethod = null;
2370 privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
2371 privateMethod.setAccessible(true);
2372 returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
2373 } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException |
2374 InvocationTargetException e) {
2375 e.printStackTrace();
2380 protected List<ComponentInstance> creatComponentInstances() {
2381 List<ComponentInstance> componentInstances = new ArrayList<>();
2382 ComponentInstance componentInstance = new ComponentInstance();
2383 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2384 List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
2385 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
2386 capabilityDefinition.setName("mme_ipu_vdu.feature");
2387 capabilityDefinitionList.add(capabilityDefinition);
2388 capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
2390 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2391 List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2392 RequirementDefinition requirementDefinition = new RequirementDefinition();
2393 requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
2394 requirementDefinitionList.add(requirementDefinition);
2395 requirements.put("tosca.capabilities.Node", requirementDefinitionList);
2396 componentInstance.setRequirements(requirements);
2397 componentInstance.setCapabilities(capabilities);
2398 componentInstance.setUniqueId("uniqueId");
2399 componentInstance.setComponentUid("componentUid");
2400 componentInstance.setName("zxjTestImportServiceAb");
2401 componentInstance.setNormalizedName("zxjTestImportServiceAb");
2402 componentInstance.setProperties(getProperties());
2403 componentInstances.add(componentInstance);
2404 return componentInstances;
2407 private CreateServiceFromYamlParameter getCsfyp() {
2408 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
2409 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2410 Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2412 csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
2413 csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
2414 csfyp.setCreatedArtifacts(createdArtifacts);
2415 csfyp.setInTransaction(true);
2416 csfyp.setShouldLock(true);
2417 csfyp.setCsarInfo(getCsarInfo());
2418 csfyp.setParsedToscaYamlInfo(getParsedToscaYamlInfo());
2419 csfyp.setNodeTypesInfo(nodeTypesInfo);
2420 csfyp.setYamlName("group.yml");
2424 private ParsedToscaYamlInfo getParsedToscaYamlInfo() {
2425 ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
2426 Map<String, InputDefinition> inputs = new HashMap<>();
2427 Map<String, UploadComponentInstanceInfo> instances = new HashMap<>();
2428 UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
2429 instances.put("instances", uploadComponentInstanceInfo);
2430 Map<String, GroupDefinition> groups = new HashMap<>();
2431 Map<String, PolicyDefinition> policies = new HashMap<>();
2432 parsedToscaYamlInfo.setGroups(groups);
2433 parsedToscaYamlInfo.setInputs(inputs);
2434 parsedToscaYamlInfo.setInstances(instances);
2435 parsedToscaYamlInfo.setPolicies(policies);
2436 return parsedToscaYamlInfo;
2439 String getMainTemplateContent(String fileName) {
2440 String mainTemplateContent = null;
2442 mainTemplateContent = loadFileNameToJsonString(fileName);
2443 } catch (IOException e) {
2444 e.printStackTrace();
2446 return mainTemplateContent;
2449 protected ServiceCsarInfo getCsarInfo() {
2450 String csarUuid = "0010";
2451 User user = new User("jh0003");
2454 File csarFile = new File(
2455 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
2456 Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
2458 String vfReousrceName = "resouceName";
2459 String mainTemplateName = "Definitions/service_import_template.yml";
2461 Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
2462 byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
2463 assertNotNull(mainTemplateService);
2464 final String mainTemplateContent = new String(mainTemplateService);
2466 return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
2467 } catch (URISyntaxException | ZipException e) {
2473 private ImmutablePair<String, byte[]> getNodeType() {
2475 File resource = new File(
2476 ServiceImportBusinessLogicTest.class.getClassLoader().getResource("node-types/resource-Extcp-template.yml").toURI());
2477 byte[] extcpResource = Files.readAllBytes(resource.toPath());
2479 return new ImmutablePair<>("org.openecomp.resource.cp.extCP", extcpResource);
2480 } catch (URISyntaxException | IOException e) {
2486 protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo() {
2487 String artifactName = "artifactName", path = "/src/test/resources/valid_vf.csar", artifactType = "AAI_SERVICE_MODEL";
2488 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
2489 String rootPath = System.getProperty("user.dir");
2491 byte[] data = new byte[0];
2492 path2 = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2494 data = Files.readAllBytes(path2);
2495 } catch (IOException e) {
2496 e.printStackTrace();
2498 String artifactUniqueId = "artifactUniqueId";
2499 boolean isFromCsar = true;
2500 CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
2501 path, artifactType, artifactGroupType, data, artifactUniqueId, isFromCsar);
2502 return nonMetaArtifactInfo;
2506 protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2507 ResponseFormat actualResponse = e.getResponseFormat() != null ?
2508 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2509 assertParseResponse(actualResponse, expectedStatus, variables);
2512 private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2513 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2514 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2515 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());