2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
19 * Modifications copyright (c) 2019 Nokia
20 * ================================================================================
23 package org.openecomp.sdc.be.components.impl;
25 import static org.assertj.core.api.Assertions.assertThat;
26 import static org.assertj.core.api.Assertions.assertThatCode;
27 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
28 import static org.junit.Assert.assertArrayEquals;
29 import static org.junit.Assert.assertEquals;
30 import static org.junit.Assert.assertNotEquals;
31 import static org.junit.Assert.assertNotNull;
32 import static org.junit.Assert.assertNull;
33 import static org.junit.Assert.assertTrue;
34 import static org.junit.Assert.fail;
35 import static org.mockito.ArgumentMatchers.any;
36 import static org.mockito.ArgumentMatchers.anyBoolean;
37 import static org.mockito.ArgumentMatchers.anyList;
38 import static org.mockito.ArgumentMatchers.anyString;
39 import static org.mockito.ArgumentMatchers.eq;
40 import static org.mockito.Mockito.doReturn;
41 import static org.mockito.Mockito.times;
42 import static org.mockito.Mockito.verify;
43 import static org.mockito.Mockito.when;
44 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
45 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
47 import com.fasterxml.jackson.annotation.JsonInclude;
48 import com.fasterxml.jackson.databind.DeserializationFeature;
49 import com.fasterxml.jackson.databind.ObjectMapper;
50 import com.fasterxml.jackson.databind.SerializationFeature;
51 import com.google.gson.Gson;
52 import com.google.gson.GsonBuilder;
53 import com.google.gson.JsonElement;
54 import fj.data.Either;
55 import java.io.IOException;
56 import java.util.ArrayList;
57 import java.util.Arrays;
58 import java.util.Collections;
59 import java.util.HashMap;
60 import java.util.List;
62 import java.util.Optional;
63 import java.util.stream.Collectors;
64 import mockit.Deencapsulation;
65 import org.apache.commons.codec.binary.Base64;
66 import org.apache.commons.collections.CollectionUtils;
67 import org.apache.commons.collections.MapUtils;
68 import org.apache.commons.lang3.tuple.ImmutablePair;
69 import org.junit.Assert;
70 import org.junit.Before;
71 import org.junit.Test;
72 import org.junit.runner.RunWith;
73 import org.mockito.InjectMocks;
74 import org.mockito.Mock;
75 import org.mockito.Mockito;
76 import org.mockito.MockitoAnnotations;
77 import org.mockito.junit.MockitoJUnitRunner;
78 import org.openecomp.sdc.be.MockGenerator;
79 import org.openecomp.sdc.be.components.ArtifactsResolver;
80 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
81 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
82 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
83 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
84 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
85 import org.openecomp.sdc.be.components.utils.ArtifactBuilder;
86 import org.openecomp.sdc.be.components.utils.ObjectGenerator;
87 import org.openecomp.sdc.be.components.validation.UserValidations;
88 import org.openecomp.sdc.be.config.ArtifactConfigManager;
89 import org.openecomp.sdc.be.config.ArtifactConfiguration;
90 import org.openecomp.sdc.be.config.ComponentType;
91 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
92 import org.openecomp.sdc.be.config.ConfigurationManager;
93 import org.openecomp.sdc.be.dao.api.ActionStatus;
94 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
95 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
96 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
97 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
98 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
99 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
100 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
101 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
102 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
103 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
104 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
105 import org.openecomp.sdc.be.impl.ComponentsUtils;
106 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
107 import org.openecomp.sdc.be.model.ArtifactDefinition;
108 import org.openecomp.sdc.be.model.ArtifactType;
109 import org.openecomp.sdc.be.model.Component;
110 import org.openecomp.sdc.be.model.ComponentInstance;
111 import org.openecomp.sdc.be.model.ComponentParametersView;
112 import org.openecomp.sdc.be.model.DataTypeDefinition;
113 import org.openecomp.sdc.be.model.GroupDefinition;
114 import org.openecomp.sdc.be.model.GroupInstance;
115 import org.openecomp.sdc.be.model.HeatParameterDefinition;
116 import org.openecomp.sdc.be.model.InterfaceDefinition;
117 import org.openecomp.sdc.be.model.LifecycleStateEnum;
118 import org.openecomp.sdc.be.model.Operation;
119 import org.openecomp.sdc.be.model.Resource;
120 import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
121 import org.openecomp.sdc.be.model.Service;
122 import org.openecomp.sdc.be.model.User;
123 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
124 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
125 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
126 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
127 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
128 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
129 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
130 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
131 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
132 import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
133 import org.openecomp.sdc.be.resources.data.DAOArtifactData;
134 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
135 import org.openecomp.sdc.be.servlets.RepresentationUtils;
136 import org.openecomp.sdc.be.tosca.CsarUtils;
137 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
138 import org.openecomp.sdc.be.user.Role;
139 import org.openecomp.sdc.be.user.UserBusinessLogic;
140 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
141 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
142 import org.openecomp.sdc.common.datastructure.Wrapper;
143 import org.openecomp.sdc.common.util.GeneralUtility;
144 import org.openecomp.sdc.exception.ResponseFormat;
146 @RunWith(MockitoJUnitRunner.Silent.class)
147 public class ArtifactsBusinessLogicTest extends BaseBusinessLogicMock {
149 public static final Resource resource = Mockito.mock(Resource.class);
150 private static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN",
151 System.currentTimeMillis());
152 private static final String RESOURCE_INSTANCE_NAME = "Service-111";
153 private static final String INSTANCE_ID = "S-123-444-ghghghg";
154 private static final String ARTIFACT_NAME = "service-Myservice-template.yml";
155 private static final String ARTIFACT_LABEL = "assettoscatemplate";
156 private static final String ES_ARTIFACT_ID = "123123dfgdfgd0";
157 private static final byte[] PAYLOAD = "some payload".getBytes();
158 private static final String RESOURCE_NAME = "My-Resource_Name with space";
159 private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
160 private static final String RESOURCE_SUBCATEGORY = "Router";
161 private static final String ARTIFACT_PLACEHOLDER_FILE_EXTENSION = "fileExtension";
162 private static User user = null;
163 private static Resource resourceResponse = null;
164 final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
166 public ComponentsUtils componentsUtils;
168 public ToscaOperationFacade toscaOperationFacade;
169 JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
171 JanusGraphDao janusGraphDao;
173 private ArtifactsBusinessLogic artifactBL;
175 private UserBusinessLogic userBusinessLogic;
177 private ArtifactOperation artifactOperation;
179 private IInterfaceLifecycleOperation lifecycleOperation;
181 private UserAdminOperation userOperation;
183 private IElementOperation elementOperation;
185 private ArtifactCassandraDao artifactCassandraDao;
187 private NodeTemplateOperation nodeTemplateOperation;
189 private IGraphLockOperation graphLockOperation;
191 private UserValidations userValidations;
193 private ArtifactsResolver artifactsResolver;
195 private CsarUtils csarUtils;
197 private ToscaExportHandler toscaExportHandler;
199 private LifecycleBusinessLogic lifecycleBusinessLogic;
201 private ArtifactTypeOperation artifactTypeOperation;
203 private Gson gson = new GsonBuilder().setPrettyPrinting().create();
205 private static List<ArtifactType> getAllTypes() {
206 final List<ArtifactConfiguration> artifactConfigurationList = ConfigurationManager.getConfigurationManager()
207 .getConfiguration().getArtifacts();
208 return artifactConfigurationList.stream().map(artifactConfiguration -> {
209 final ArtifactType artifactType = new ArtifactType();
210 artifactType.setName(artifactConfiguration.getType());
212 }).collect(Collectors.toList());
216 public void initMocks() {
217 MockitoAnnotations.openMocks(this);
218 Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
219 .right(StorageOperationStatus.NOT_FOUND);
221 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either
222 .right(StorageOperationStatus.NOT_FOUND);
223 when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Service), Mockito.anyBoolean()))
224 .thenReturn(NotFoundResult2);
225 when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Resource), Mockito.anyBoolean()))
226 .thenReturn(NotFoundResult2);
228 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
229 .right(StorageOperationStatus.NOT_FOUND);
230 when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
231 .thenReturn(notFoundInterfaces);
233 when(userOperation.getUserData("jh0003", false)).thenReturn(Either.left(USER));
235 when(elementOperation.getAllArtifactTypes()).thenReturn(getAllTypes());
237 when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
239 // User data and management
241 user.setUserId("jh0003");
242 user.setFirstName("Jimmi");
243 user.setLastName("Hendrix");
244 user.setRole(Role.ADMIN.name());
247 resourceResponse = createResourceObject(true);
248 Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
249 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
250 when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(StorageOperationStatus.OK);
251 Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
252 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(emptyDataTypes));
253 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
255 Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
256 .right(StorageOperationStatus.BAD_REQUEST);
257 when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
258 .thenReturn(resourceStorageOperationStatusEither);
262 public void testValidJson() {
263 ArtifactDefinition ad = createArtifactDef();
265 String jsonArtifact = "";
267 ObjectMapper mapper = new ObjectMapper();
268 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
269 mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
270 mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
273 jsonArtifact = mapper.writeValueAsString(ad);
274 } catch (IOException e) {
275 // TODO Auto-generated catch block
279 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
280 ArtifactDefinition.class, false);
281 assertEquals(ad, afterConvert);
284 private ArtifactDefinition createArtifactDef() {
285 ArtifactDefinition ad = new ArtifactDefinition();
286 ad.setArtifactName("artifact1.yaml");
287 ad.setArtifactLabel("label1");
288 ad.setDescription("description");
289 ad.setArtifactType(ArtifactTypeEnum.HEAT.getType());
290 ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
291 ad.setCreationDate(System.currentTimeMillis());
292 ad.setMandatory(false);
297 private Resource createResourceObject(boolean afterCreate) {
298 Resource resource = new Resource();
299 resource.setName(RESOURCE_NAME);
300 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
301 resource.setDescription("My short description");
302 List<String> tgs = new ArrayList<String>();
304 tgs.add(resource.getName());
305 resource.setTags(tgs);
306 List<String> template = new ArrayList<String>();
307 template.add("Root");
308 resource.setDerivedFrom(template);
309 resource.setVendorName("Motorola");
310 resource.setVendorRelease("1.0.0");
311 resource.setContactId("ya5467");
312 resource.setIcon("MyIcon");
315 resource.setName(resource.getName());
316 resource.setVersion("0.1");
317 resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
318 resource.setCreatorUserId(user.getUserId());
319 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
320 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
326 public void testUpdateCIDeploymentArtifactTimeout() {
327 ArtifactDefinition heatArtifact = new ArtifactDefinition();
328 ArtifactDefinition envArtifact = new ArtifactDefinition();
329 ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
330 ComponentInstance ci = new ComponentInstance();
331 ci.setUniqueId("ciid");
332 ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
333 GroupInstance groupInstance = new GroupInstance();
334 groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
335 groupInstance.setCustomizationUUID("custUid");
336 groupInstance.setUniqueId("guid");
337 List<GroupInstance> groupInstances = new ArrayList<>();
338 groupInstances.addAll(Arrays.asList(groupInstance));
339 ci.setGroupInstances(groupInstances);
340 Service service = new Service();
341 service.setComponentInstances(Collections.singletonList(ci));
342 service.setUniqueId("suid");
344 when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
345 heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
346 Either.left(heatArtifact));
347 when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
348 .thenReturn(StorageOperationStatus.OK);
349 when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
350 .thenReturn(Either.left(new ArrayList()));
351 when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
352 new ArrayList<>(Arrays.asList("guid"))))
353 .thenReturn(StorageOperationStatus.OK);
354 artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
355 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
356 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
357 assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(envArtifact.getTimeout());
358 assertThat(ci.getDeploymentArtifacts().get("HEAT_ENV").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
362 public void testUpdateCIDeploymentTimeout_invalidTimeout() {
363 ArtifactDefinition heatArtifact = new ArtifactDefinition();
364 ArtifactDefinition envArtifact = new ArtifactDefinition();
365 ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
366 ComponentInstance ci = new ComponentInstance();
367 ci.setUniqueId("ciid");
368 ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
369 GroupInstance groupInstance = new GroupInstance();
370 groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
371 groupInstance.setCustomizationUUID("custUid");
372 groupInstance.setUniqueId("guid");
373 List<GroupInstance> groupInstances = new ArrayList<>();
374 groupInstances.addAll(Arrays.asList(groupInstance));
375 ci.setGroupInstances(groupInstances);
376 Service service = new Service();
377 service.setComponentInstances(Collections.singletonList(ci));
378 service.setUniqueId("suid");
379 envArtifact.setTimeout(130);
381 when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
382 heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
383 Either.left(heatArtifact));
384 when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
385 .thenReturn(StorageOperationStatus.OK);
386 when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
387 .thenReturn(Either.left(new ArrayList()));
388 when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
389 new ArrayList<>(Arrays.asList("guid"))))
390 .thenReturn(StorageOperationStatus.OK);
392 artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
393 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
394 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
395 } catch (ComponentException exp) {
396 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
403 public void testUpdateCIDeploymentTimeout_negativeTimeout() {
404 ArtifactDefinition heatArtifact = new ArtifactDefinition();
405 ArtifactDefinition envArtifact = new ArtifactDefinition();
406 ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
407 ComponentInstance ci = new ComponentInstance();
408 ci.setUniqueId("ciid");
409 ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
410 GroupInstance groupInstance = new GroupInstance();
411 groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
412 groupInstance.setCustomizationUUID("custUid");
413 groupInstance.setUniqueId("guid");
414 List<GroupInstance> groupInstances = new ArrayList<>();
415 groupInstances.addAll(Arrays.asList(groupInstance));
416 ci.setGroupInstances(groupInstances);
417 Service service = new Service();
418 service.setComponentInstances(Collections.singletonList(ci));
419 service.setUniqueId("suid");
420 envArtifact.setTimeout(-1);
422 when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
423 heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
424 Either.left(heatArtifact));
425 when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
426 .thenReturn(StorageOperationStatus.OK);
427 when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
428 .thenReturn(Either.left(new ArrayList()));
429 when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
430 new ArrayList<>(Arrays.asList("guid"))))
431 .thenReturn(StorageOperationStatus.OK);
433 artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
434 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
435 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
436 } catch (ComponentException exp) {
437 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
444 public void testUpdateCIDeploymentArtifactTimeout_noUpdate() {
445 ArtifactDefinition heatArtifact = new ArtifactDefinition();
446 ArtifactDefinition envArtifact = new ArtifactDefinition();
447 ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
448 ComponentInstance ci = new ComponentInstance();
449 ci.setUniqueId("ciid");
450 ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
451 envArtifact.setTimeout(heatArtifact.getTimeout());
452 GroupInstance groupInstance = new GroupInstance();
453 groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
454 groupInstance.setCustomizationUUID("custUid");
455 groupInstance.setUniqueId("guid");
456 List<GroupInstance> groupInstances = new ArrayList<>();
457 groupInstances.addAll(Arrays.asList(groupInstance));
458 ci.setGroupInstances(groupInstances);
459 Service service = new Service();
460 service.setComponentInstances(Collections.singletonList(ci));
461 service.setUniqueId("suid");
463 when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
464 .thenReturn(StorageOperationStatus.OK);
465 when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
466 .thenReturn(Either.left(new ArrayList()));
467 artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
468 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
469 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
470 assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
474 public void testUpdateCIDeploymentArtifactTimeout_nonExistingArtifact() {
475 ArtifactDefinition heatArtifact = new ArtifactDefinition();
476 ArtifactDefinition envArtifact = new ArtifactDefinition();
477 ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
478 envArtifact.setTimeout(heatArtifact.getTimeout());
479 envArtifact.setArtifactType("HEAT_ENV");
480 envArtifact.setGeneratedFromId("uid1");
481 ComponentInstance ci = new ComponentInstance();
482 ci.setUniqueId("ciid");
483 ci.setDeploymentArtifacts(new HashMap<>());
484 Service service = new Service();
485 service.setComponentInstances(Collections.singletonList(ci));
486 service.setUniqueId("suid");
488 when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
489 .thenReturn(StorageOperationStatus.OK);
490 when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
491 .thenReturn(Either.left(new ArrayList()));
492 assertThatThrownBy(() -> {
493 artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
494 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
495 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
496 }).isInstanceOf(ComponentException.class);
500 public void testUpdateCIDeploymentArtifactTimeout_invalidArtifactType() {
501 ArtifactDefinition envArtifact = new ArtifactDefinition();
502 envArtifact.setArtifactType("invalid");
505 artifactBL.handleUpdate("uid", ComponentTypeEnum.RESOURCE_INSTANCE, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
506 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, null, true);
508 } catch (ComponentException exp) {
509 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED);
510 assertThat(exp.getParams()[0]).isEqualTo("invalid");
514 private Map<String, ArtifactDefinition> fillDeploymentArtifacts(ArtifactDefinition heatArtifact, ArtifactDefinition envArtifact,
515 ArtifactDefinition origEnvArtifact) {
516 heatArtifact.setArtifactType("HEAT");
517 heatArtifact.setTimeout(60);
518 heatArtifact.setEsId("es");
519 heatArtifact.setArtifactUUID("uuid1");
520 heatArtifact.setUniqueId("uid1");
521 envArtifact.setArtifactUUID("uuid2");
522 envArtifact.setArtifactType("HEAT_ENV");
523 envArtifact.setTimeout(30);
524 envArtifact.setGenerated(true);
525 envArtifact.setGeneratedFromId("uid1");
526 envArtifact.setUniqueId("uid2");
527 origEnvArtifact.setUniqueId("uid2");
528 origEnvArtifact.setGeneratedFromId("uid1");
529 origEnvArtifact.setArtifactType("HEAT_ENV");
530 origEnvArtifact.setTimeout(60);
531 origEnvArtifact.setGenerated(true);
532 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
533 deploymentArtifacts.put(heatArtifact.getArtifactType(), heatArtifact);
534 //deploymentArtifacts.put(envArtifact.getArtifactType(), envArtifact);
535 deploymentArtifacts.put(envArtifact.getArtifactType(), origEnvArtifact);
536 return deploymentArtifacts;
540 public void testInvalidStringGroupType() {
541 ArtifactDefinition ad = new ArtifactDefinition();
542 ad.setArtifactName("artifact1");
543 ad.setCreationDate(System.currentTimeMillis());
544 ad.setMandatory(false);
547 JsonElement jsonArtifact = gson.toJsonTree(ad);
548 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
549 jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
550 jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
551 jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
553 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
554 ArtifactDefinition.class, false);
555 assertNull(afterConvert);
559 public void testUpdateArtifactWithEmptyBody() {
561 RepresentationUtils.convertJsonToArtifactDefinition("", ArtifactDefinition.class, true);
563 } catch (ComponentException exp) {
564 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_BODY);
569 public void testInvalidNumberGroupType() {
570 ArtifactDefinition ad = new ArtifactDefinition();
571 ad.setArtifactName("artifact1");
572 ad.setCreationDate(System.currentTimeMillis());
573 ad.setMandatory(false);
576 JsonElement jsonArtifact = gson.toJsonTree(ad);
577 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
578 jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
579 jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
580 jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
582 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
583 ArtifactDefinition.class, false);
584 assertNull(afterConvert);
588 public void testMissingArtifactTypeValue() {
589 ArtifactDefinition ad = new ArtifactDefinition();
591 JsonElement jsonArtifact = gson.toJsonTree(ad);
592 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
593 jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
594 jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
595 jsonArtifact.getAsJsonObject().add("artifactType", null);
597 RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
598 ArtifactDefinition.class, true);
600 } catch (ComponentException exp) {
601 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MANDATORY_PROPERTY_MISSING_VALUE);
602 assertThat(exp.getParams()[0]).isEqualTo("artifactType");
607 public void testMissingArtifactLabel() {
608 ArtifactDefinition ad = new ArtifactDefinition();
610 JsonElement jsonArtifact = gson.toJsonTree(ad);
611 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
612 jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
613 jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
616 RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
617 ArtifactDefinition.class, false);
619 } catch (ComponentException exp) {
620 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
621 assertThat(exp.getParams()[0]).isEqualTo("artifactLabel");
626 public void testMissingArtifactTimeout() {
627 ArtifactDefinition ad = new ArtifactDefinition();
629 JsonElement jsonArtifact = gson.toJsonTree(ad);
630 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
631 jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
632 jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
635 RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
636 ArtifactDefinition.class, true);
638 } catch (ComponentException exp) {
639 assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
640 assertThat(exp.getParams()[0]).isEqualTo("timeout");
646 public void testInvalidGroupTypeWithSpace() {
647 ArtifactDefinition ad = new ArtifactDefinition();
648 ad.setArtifactName("artifact1");
649 ad.setCreationDate(System.currentTimeMillis());
650 ad.setMandatory(false);
653 JsonElement jsonArtifact = gson.toJsonTree(ad);
654 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
655 jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
656 jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
657 jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
659 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
660 ArtifactDefinition.class, false);
661 assertNull(afterConvert);
665 public void testInvalidTimeoutWithSpace() {
666 ArtifactDefinition ad = new ArtifactDefinition();
667 ad.setArtifactName("artifact1");
668 ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
669 ad.setCreationDate(System.currentTimeMillis());
670 ad.setMandatory(false);
672 JsonElement jsonArtifact = gson.toJsonTree(ad);
673 jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
674 jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
675 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
676 jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
678 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
679 ArtifactDefinition.class, true);
680 assertNull(afterConvert);
684 public void testValidMibArtifactsConfiguration() {
685 final ArtifactConfigManager artifactConfigManager = ArtifactConfigManager.getInstance();
686 Optional<ArtifactConfiguration> artifactConfiguration = artifactConfigManager
687 .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
688 assertThat(artifactConfiguration.isPresent()).isTrue();
690 artifactConfiguration = artifactConfigManager
691 .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
692 assertThat(artifactConfiguration.isPresent()).isTrue();
694 artifactConfiguration = artifactConfigManager
695 .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
696 assertThat(artifactConfiguration.isPresent()).isTrue();
697 artifactConfiguration = artifactConfigManager
698 .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
699 assertThat(artifactConfiguration.isPresent()).isTrue();
703 public void testDownloadServiceArtifactByNames() {
704 Service service = new Service();
705 String serviceName = "myService";
706 String serviceVersion = "1.0";
707 String serviceId = "serviceId";
708 service.setName(serviceName);
709 service.setVersion(serviceVersion);
710 service.setUniqueId(serviceId);
712 String artifactName = "service-Myservice-template.yml";
713 String artifactLabel = "assettoscatemplate";
714 String esArtifactId = "123123dfgdfgd0";
715 byte[] payload = "some payload".getBytes();
716 ArtifactDefinition toscaTemplateArtifact = new ArtifactDefinition();
717 toscaTemplateArtifact.setArtifactName(artifactName);
718 toscaTemplateArtifact.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
719 toscaTemplateArtifact.setArtifactLabel(artifactLabel);
720 toscaTemplateArtifact.setEsId(esArtifactId);
721 toscaTemplateArtifact.setPayload(payload);
723 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
724 toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
725 service.setToscaArtifacts(toscaArtifacts);
727 DAOArtifactData DAOArtifactData = new DAOArtifactData(esArtifactId);
728 DAOArtifactData.setDataAsArray(payload);
729 Either<DAOArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(DAOArtifactData);
730 when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
731 when(toscaOperationFacade.getBySystemNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, serviceVersion)).thenReturn(Either.left(service));
732 byte[] downloadServiceArtifactByNamesRes = artifactBL
733 .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
734 assertThat(downloadServiceArtifactByNamesRes != null
735 && downloadServiceArtifactByNamesRes.length == payload.length).isTrue();
739 public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
740 ArtifactDefinition heatArtifact = new ArtifactBuilder()
741 .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
742 .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
744 Resource component = new Resource();
745 component.setComponentType(ComponentTypeEnum.RESOURCE);
746 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
747 when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
748 eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
749 .thenReturn(Either.left(new ArtifactDefinition()));
750 ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
751 new ArrayList<>(), heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
752 Collections.emptyMap());
753 assertNull(heatEnvPlaceHolder.getListHeatParameters());
757 public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
759 HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
760 HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
761 HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
762 ArtifactDefinition heatArtifact = new ArtifactBuilder().addHeatParam(heatParam1).addHeatParam(heatParam2)
763 .addHeatParam(heatParam3).build();
765 Resource component = new Resource();
767 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
768 when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
769 eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
770 .thenReturn(Either.left(new ArtifactDefinition()));
772 ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
773 new ArrayList<>(), heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
774 Collections.emptyMap());
776 ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder;
777 List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
778 assertEquals(listHeatParameters.size(), 3);
779 verifyHeatParam(listHeatParameters.get(0), heatParam1);
780 verifyHeatParam(listHeatParameters.get(1), heatParam2);
781 verifyHeatParam(listHeatParameters.get(2), heatParam3);
785 public void buildArtifactPayloadWhenShouldLockAndInTransaction() {
786 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
787 artifactDefinition.setArtifactName(ARTIFACT_NAME);
788 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
789 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
790 artifactDefinition.setEsId(ES_ARTIFACT_ID);
791 artifactDefinition.setPayload(PAYLOAD);
792 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
794 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
795 when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
796 any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
797 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
798 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
799 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
800 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
804 public void buildArtifactPayloadWhenShouldLockAndNotInTransaction() {
805 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
806 artifactDefinition.setArtifactName(ARTIFACT_NAME);
807 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
808 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
809 artifactDefinition.setEsId(ES_ARTIFACT_ID);
810 artifactDefinition.setPayload(PAYLOAD);
811 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
813 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
814 when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
815 any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
816 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
817 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
818 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
819 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
820 verify(janusGraphDao, times(1)).commit();
823 private ArtifactDefinition buildArtifactPayload() {
824 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
825 artifactDefinition.setArtifactName(ARTIFACT_NAME);
826 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
827 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
828 artifactDefinition.setEsId(ES_ARTIFACT_ID);
829 artifactDefinition.setPayload(PAYLOAD);
830 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
832 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
833 when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
834 any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
835 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
836 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
837 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
838 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
839 verify(janusGraphDao, times(1)).commit();
840 return artifactDefinition;
843 private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
844 assertEquals(heatEnvParam.getDefaultValue(), heatYamlParam.getCurrentValue());
845 assertNull(heatEnvParam.getCurrentValue());
848 //////////////////////////////////////////////////////////////////////////////////
849 //////////////////////////////////new tests///////////////////////////////////////
850 /////////////////////////////////////////////////////////////////////////////////
851 private ArtifactsBusinessLogic createTestSubject() {
852 return getTestSubject();
856 public void testCheckCreateFields() throws Exception {
857 ArtifactsBusinessLogic testSubject;
859 ArtifactDefinition artifactInfo = buildArtifactPayload();
860 ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
863 testSubject = createTestSubject();
864 Deencapsulation.invoke(testSubject, "checkCreateFields", user, artifactInfo, type);
868 public void testComposeArtifactId() throws Exception {
869 ArtifactsBusinessLogic testSubject;
870 String resourceId = "";
871 String artifactId = "";
872 ArtifactDefinition artifactInfo = buildArtifactPayload();
873 String interfaceName = "";
874 String operationName = "";
878 testSubject = createTestSubject();
879 result = Deencapsulation.invoke(testSubject, "composeArtifactId",
880 new Object[]{resourceId, artifactId, artifactInfo, interfaceName, operationName});
884 public void testConvertParentType() throws Exception {
885 ArtifactsBusinessLogic testSubject;
886 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
890 testSubject = createTestSubject();
891 result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[]{componentType});
895 public void testConvertToOperation() throws Exception {
896 ArtifactsBusinessLogic testSubject;
897 ArtifactDefinition artifactInfo = buildArtifactPayload();
898 String operationName = "";
902 testSubject = createTestSubject();
903 result = Deencapsulation.invoke(testSubject, "convertToOperation",
904 new Object[]{artifactInfo, operationName});
908 public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
909 ArtifactsBusinessLogic testSubject;
910 String operationName = "";
911 String artifactName = "";
915 testSubject = createTestSubject();
916 result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
917 new Object[]{operationName, artifactName});
921 public void testFetchArtifactsFromComponent() throws Exception {
922 ArtifactsBusinessLogic testSubject;
923 String artifactId = "";
924 Component component = createResourceObject(true);
925 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
928 testSubject = createTestSubject();
929 Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
930 artifactId, component, artifacts);
934 public void testValidateArtifact() throws Exception {
935 ArtifactsBusinessLogic testSubject;
936 String componentId = "";
937 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
938 ArtifactsBusinessLogic arb = getTestSubject();
939 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
940 String artifactId = "";
941 ArtifactDefinition artifactInfo = buildArtifactPayload();
942 AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
944 Component component = createResourceObject(true);
945 boolean shouldLock = false;
946 boolean inTransaction = false;
949 testSubject = createTestSubject();
950 testSubject.validateArtifact(componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, shouldLock,
955 public void testHandleHeatEnvDownload() throws Exception {
956 ArtifactsBusinessLogic testSubject;
957 String componentId = "";
958 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
960 Component component = createResourceObject(true);
961 ArtifactDefinition artifactInfo = buildArtifactPayload();
962 boolean shouldLock = false;
963 boolean inTransaction = false;
966 testSubject = createTestSubject();
967 testSubject.handleHeatEnvDownload(componentId, componentType, user, component, artifactInfo, shouldLock, inTransaction);
971 public void testArtifactGenerationRequired() throws Exception {
972 ArtifactsBusinessLogic testSubject;
973 Component component = createResourceObject(true);
974 ArtifactDefinition artifactInfo = buildArtifactPayload();
978 testSubject = createTestSubject();
979 result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
980 new Object[]{component, artifactInfo});
984 public void testUpdateGroupForHeat() throws Exception {
985 ArtifactsBusinessLogic testSubject;
986 ArtifactDefinition artifactInfo = buildArtifactPayload();
987 ArtifactDefinition artAfterUpdate = null;
988 Component component = createResourceObject(true);
989 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
992 testSubject = createTestSubject();
993 testSubject.updateGroupForHeat(artifactInfo, artifactInfo, component);
997 public void testUpdateGroupForHeat_1() throws Exception {
998 ArtifactsBusinessLogic testSubject;
999 ArtifactDefinition artifactInfo = buildArtifactPayload();
1000 Component component = createResourceObject(true);
1001 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1004 testSubject = createTestSubject();
1005 testSubject.updateGroupForHeat(artifactInfo, artifactInfo, artifactInfo,
1006 artifactInfo, component);
1011 public void testHandleAuditing() throws Exception {
1012 ArtifactsBusinessLogic testSubject;
1013 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1014 Component component = createResourceObject(true);
1015 String componentId = "";
1017 ArtifactDefinition artifactDefinition = buildArtifactPayload();
1018 String prevArtifactUuid = "";
1019 String currentArtifactUuid = "";
1020 ResponseFormat responseFormat = new ResponseFormat();
1021 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1022 String resourceInstanceName = "";
1025 testSubject = createTestSubject();
1026 testSubject.setComponentsUtils(MockGenerator.mockComponentUtils());
1027 testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
1028 prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
1032 public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
1033 ArtifactsBusinessLogic testSubject;
1034 ArtifactsBusinessLogic arb = getTestSubject();
1035 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1036 ArtifactDefinition artifactInfo = buildArtifactPayload();
1037 ArtifactDefinition currentArtifactInfo = null;
1040 testSubject = createTestSubject();
1041 Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
1042 operation, artifactInfo, artifactInfo);
1046 public void testFindArtifactOnParentComponent() {
1047 ArtifactsBusinessLogic testSubject;
1048 Component component = createResourceObject(true);
1049 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1050 String parentId = "";
1051 ArtifactsBusinessLogic arb = getTestSubject();
1052 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1053 String artifactId = "";
1054 Either<ArtifactDefinition, ResponseFormat> result;
1057 testSubject = createTestSubject();
1058 result = Deencapsulation.invoke(testSubject, "findArtifact", new Object[]{component,
1059 componentType, parentId, operation, artifactId});
1064 public void testValidateInformationalArtifact() throws Exception {
1065 ArtifactsBusinessLogic testSubject;
1066 ArtifactDefinition artifactInfo = buildArtifactPayload();
1067 Component component = createResourceObject(true);
1068 Either<Boolean, ResponseFormat> result;
1071 testSubject = createTestSubject();
1072 result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
1073 new Object[]{artifactInfo, component});
1078 public void testGetUpdatedGroups() throws Exception {
1079 ArtifactsBusinessLogic testSubject;
1080 String artifactId = "";
1081 ArtifactDefinition artifactInfo = buildArtifactPayload();
1082 List<GroupDefinition> groups = new ArrayList<>();
1083 List<GroupDataDefinition> result;
1086 testSubject = createTestSubject();
1087 result = Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
1092 public void testGetUpdatedGroupInstances() throws Exception {
1093 ArtifactsBusinessLogic testSubject;
1094 String artifactId = "";
1095 ArtifactDefinition artifactInfo = buildArtifactPayload();
1096 List<GroupDefinition> groups = new ArrayList<>();
1097 List<GroupInstance> result;
1100 testSubject = createTestSubject();
1101 result = Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
1106 public void testFindArtifact_1() throws Exception {
1107 ArtifactsBusinessLogic testSubject;
1108 String artifactId = "";
1109 Component component = createResourceObject(true);
1110 String parentId = "";
1111 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1112 Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> result;
1115 testSubject = createTestSubject();
1116 result = Deencapsulation.invoke(testSubject, "findArtifact",
1117 new Object[]{artifactId, component, parentId, componentType});
1122 public void testFetchArtifactsFromInstance() throws Exception {
1123 ArtifactsBusinessLogic testSubject;
1124 String artifactId = "";
1125 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1126 ComponentInstance instance = new ComponentInstance();
1129 testSubject = createTestSubject();
1130 Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
1135 public void testGenerateCustomizationUUIDOnInstance() throws Exception {
1136 ArtifactsBusinessLogic testSubject;
1137 String componentId = "";
1138 String instanceId = "";
1139 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1140 StorageOperationStatus result;
1143 testSubject = createTestSubject();
1144 result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
1145 new Object[]{componentId, instanceId, componentType});
1149 public void testFindComponentInstance() {
1150 ArtifactsBusinessLogic testSubject;
1151 String componentInstanceId = "";
1152 Component component = createResourceObject(true);
1153 ComponentInstance result;
1156 testSubject = createTestSubject();
1157 result = Deencapsulation.invoke(testSubject, "findComponentInstance",
1158 new Object[]{componentInstanceId, component});
1161 @Test(expected = ComponentException.class)
1162 public void testDeploymentArtifactTypeIsLegalForParent_shouldThrowException() {
1163 ArtifactsBusinessLogic testSubject;
1164 ArtifactDefinition artifactInfo = buildArtifactPayload();
1165 ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
1166 Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts = new HashMap<>();
1168 testSubject = createTestSubject();
1169 testSubject.validateDeploymentArtifactTypeIsLegalForParent(artifactInfo, artifactType, resourceDeploymentArtifacts);
1173 public void testLoadArtifactTypeConfig() {
1174 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1176 Optional<ArtifactConfiguration> artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(null);
1177 assertThat(artifactConfiguration.isPresent()).isFalse();
1178 //not configured artifactType
1179 artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig("NotConfiguredArtifactType");
1180 assertThat(artifactConfiguration.isPresent()).isFalse();
1182 //valid artifactType
1183 final String artifactType = ArtifactTypeEnum.YANG.getType();
1184 artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(artifactType);
1185 assertThat(artifactConfiguration.isPresent()).isTrue();
1186 final ArtifactConfiguration artifactConfiguration1 = artifactConfiguration.get();
1187 assertThat(artifactConfiguration1.getType()).isEqualTo(artifactType);
1188 assertThat(artifactConfiguration1.getCategories()).hasSize(1);
1189 assertThat(artifactConfiguration1.getCategories()).contains(ArtifactGroupTypeEnum.INFORMATIONAL);
1190 assertThat(artifactConfiguration1.getComponentTypes()).hasSize(1);
1191 assertThat(artifactConfiguration1.getComponentTypes()).contains(ComponentType.RESOURCE);
1192 assertThat(artifactConfiguration1.getResourceTypes()).hasSize(11);
1193 assertThat(artifactConfiguration1.getResourceTypes())
1194 .contains(ResourceTypeEnum.VFC.getValue(), ResourceTypeEnum.CP.getValue(), ResourceTypeEnum.VL.getValue(),
1195 ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.VFCMT.getValue(), "Abstract",
1196 ResourceTypeEnum.CVFC.getValue());
1200 public void testValidateArtifactExtension_acceptedExtension() {
1201 final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1202 artifactInfo.setArtifactName("artifact.yml");
1203 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1204 //empty accepted types
1205 assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(new ArtifactConfiguration(), artifactInfo))
1206 .doesNotThrowAnyException();
1208 final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1209 artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1210 assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo))
1211 .doesNotThrowAnyException();
1214 @Test(expected = ComponentException.class)
1215 public void testValidateArtifactExtension_notAcceptedExtension() {
1216 final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1217 artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1218 final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1219 //not accepted extension
1220 artifactInfo.setArtifactName("artifact.xml");
1222 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1224 artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1227 @Test(expected = ComponentException.class)
1228 public void testValidateArtifactExtension_noExtension() {
1229 final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1230 artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1231 final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1232 //no extension in the artifact name
1233 artifactInfo.setArtifactName("artifact");
1235 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1237 artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1240 @Test(expected = ComponentException.class)
1241 public void testValidateHeatEnvDeploymentArtifact_shouldThrowException() {
1242 ArtifactsBusinessLogic testSubject;
1243 Component component = createResourceObject(true);
1244 String parentId = "";
1245 ArtifactDefinition artifactInfo = buildArtifactPayload();
1247 testSubject = createTestSubject();
1248 testSubject.validateHeatEnvDeploymentArtifact(component, parentId, artifactInfo);
1252 public void testFillArtifactPayloadValidation() throws Exception {
1253 ArtifactsBusinessLogic testSubject;
1254 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1255 Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1256 ArtifactDefinition artifactDefinition = buildArtifactPayload();
1259 testSubject = createTestSubject();
1260 testSubject.fillArtifactPayload(payloadWrapper, artifactDefinition);
1263 @Test(expected = ByActionStatusComponentException.class)
1264 public void testHeatTimeoutValue() {
1265 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1266 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1267 artifactInfo.setTimeout(1);
1268 artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1269 artifactInfo.setTimeout(0);
1270 artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1274 public void testValidateResourceType_resourceTypeIsAccepted() {
1275 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1276 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1277 final List<String> typeList = Arrays
1278 .asList(ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.PNF.getValue(), ResourceTypeEnum.VFC.getValue());
1279 assertThatCode(() -> {
1280 artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1281 }).doesNotThrowAnyException();
1284 @Test(expected = ComponentException.class)
1285 public void testValidateResourceType_invalidResourceType() {
1286 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1287 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1288 final List<String> typeList = Collections.singletonList(ResourceTypeEnum.PNF.getValue());
1289 artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1293 public void testValidateResourceType_emptyResourceTypeConfig_resourceTypeIsAccepted() {
1294 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1295 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1296 assertThatCode(() -> {
1297 artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, null);
1298 }).doesNotThrowAnyException();
1299 assertThatCode(() -> {
1300 artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, new ArrayList<>());
1301 }).doesNotThrowAnyException();
1305 public void testValidateAndConvertHeatParameters() throws Exception {
1306 ArtifactsBusinessLogic testSubject;
1307 ArtifactDefinition artifactInfo = buildArtifactPayload();
1308 String artifactType = "";
1309 Either<ArtifactDefinition, ResponseFormat> result;
1312 testSubject = createTestSubject();
1313 testSubject.validateAndConvertHeatParameters(artifactInfo, artifactType);
1317 public void testGetDeploymentArtifacts() throws Exception {
1318 ArtifactsBusinessLogic testSubject;
1319 Component component = createResourceObject(true);
1320 NodeTypeEnum parentType = null;
1322 List<ArtifactDefinition> result;
1325 testSubject = createTestSubject();
1326 result = testSubject.getDeploymentArtifacts(component, ciId);
1331 public void testValidateFirstUpdateHasPayload() throws Exception {
1332 ArtifactsBusinessLogic testSubject;
1333 ArtifactDefinition artifactInfo = buildArtifactPayload();
1334 ArtifactDefinition currentArtifact = null;
1335 Either<Boolean, ResponseFormat> result;
1338 testSubject = createTestSubject();
1339 result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1340 new Object[]{artifactInfo, artifactInfo});
1344 public void testValidateAndSetArtifactname() throws Exception {
1345 ArtifactsBusinessLogic testSubject;
1346 ArtifactDefinition artifactInfo = buildArtifactPayload();
1347 Either<Boolean, ResponseFormat> result;
1350 testSubject = createTestSubject();
1351 testSubject.validateAndSetArtifactName(artifactInfo);
1354 @Test(expected = ComponentException.class)
1355 public void testValidateArtifactType_notConfiguredArtifactType() {
1356 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1357 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1358 artifactInfo.setArtifactType("notConfiguredType");
1360 .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1363 @Test(expected = ComponentException.class)
1364 public void testValidateArtifactType_componentTypeNotSupportedByArtifactType() {
1365 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1366 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1367 artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1370 .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1373 @Test(expected = ComponentException.class)
1374 public void testValidateArtifactType_groupTypeNotSupportedByArtifactType() {
1375 final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1376 final ArtifactDefinition artifactInfo = buildArtifactPayload();
1377 artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1378 artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1381 .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.SERVICE);
1385 public void testValidateArtifactTypeNotChanged() throws Exception {
1386 ArtifactsBusinessLogic testSubject;
1387 ArtifactDefinition artifactInfo = buildArtifactPayload();
1388 ArtifactDefinition currentArtifact = null;
1389 Either<Boolean, ResponseFormat> result;
1392 testSubject = createTestSubject();
1393 result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1394 new Object[]{artifactInfo, artifactInfo});
1399 public void testValidateOrSetArtifactGroupType() throws Exception {
1400 ArtifactsBusinessLogic testSubject;
1401 ArtifactDefinition artifactInfo = buildArtifactPayload();
1402 ArtifactDefinition currentArtifact = null;
1403 Either<ArtifactDefinition, ResponseFormat> result;
1406 testSubject = createTestSubject();
1407 result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1408 new Object[]{artifactInfo, artifactInfo});
1412 public void testCheckAndSetUnUpdatableFields() throws Exception {
1413 ArtifactsBusinessLogic testSubject;
1415 ArtifactDefinition artifactInfo = buildArtifactPayload();
1416 ArtifactDefinition currentArtifact = null;
1417 ArtifactGroupTypeEnum type = null;
1420 testSubject = createTestSubject();
1422 Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", user,
1423 artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class);
1427 public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1428 ArtifactsBusinessLogic testSubject;
1429 List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1430 List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1433 testSubject = createTestSubject();
1434 Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1438 public void testGetMapOfParameters() throws Exception {
1439 ArtifactsBusinessLogic testSubject;
1440 List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1441 Map<String, HeatParameterDefinition> result;
1444 testSubject = createTestSubject();
1445 result = Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1449 public void testGivenValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1450 final byte[] payload = "validYaml: yes".getBytes();
1451 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1453 final boolean isArtifactMetadataUpdate = false;
1454 ArtifactsBusinessLogic testSubject = getTestSubject();
1456 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1457 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1458 assertArrayEquals(payload, result.left().value());
1463 public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1464 final int expectedStatus = 100;
1465 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1466 final byte[] payload = "invalidYaml".getBytes();
1467 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1469 final boolean isArtifactMetadataUpdate = false;
1470 ArtifactsBusinessLogic testSubject = getTestSubject();
1471 testSubject.setComponentsUtils(componentsUtils);
1473 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1474 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1476 int status = result.right().value().getStatus();
1477 assertEquals(expectedStatus, status);
1481 public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
1482 final int expectedStatus = 101;
1483 when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1484 final byte[] payload = "".getBytes();
1485 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1487 final boolean isArtifactMetadataUpdate = false;
1488 ArtifactsBusinessLogic testSubject = getTestSubject();
1489 testSubject.setComponentsUtils(componentsUtils);
1491 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1492 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1494 int status = result.right().value().getStatus();
1495 assertEquals(expectedStatus, status);
1500 public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1501 final byte[] payload = "heat_template_version: 1.0".getBytes();
1502 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1504 final boolean isArtifactMetadataUpdate = false;
1505 ArtifactsBusinessLogic testSubject = getTestSubject();
1507 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1508 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1509 assertArrayEquals(payload, result.left().value());
1513 public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1514 final int expectedStatus = 1000;
1515 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(
1516 new ResponseFormat(expectedStatus));
1517 final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
1518 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1520 final boolean isArtifactMetadataUpdate = false;
1521 ArtifactsBusinessLogic testSubject = getTestSubject();
1522 testSubject.setComponentsUtils(componentsUtils);
1524 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1525 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1527 int status = result.right().value().getStatus();
1528 assertEquals(expectedStatus, status);
1531 private ArtifactDefinition createArtifactInfo(byte[] payload, String artifactName, ArtifactTypeEnum artifactType) {
1532 ArtifactDefinition artifactInfo = new ArtifactDefinition();
1533 artifactInfo.setArtifactName(artifactName);
1534 artifactInfo.setArtifactType(artifactType.getType());
1535 artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1536 artifactInfo.setPayload(Base64.encodeBase64(payload));
1537 return artifactInfo;
1541 public void testValidateUserRole() throws Exception {
1542 ArtifactsBusinessLogic testSubject;
1544 AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
1545 String componentId = "";
1546 String artifactId = "";
1547 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1548 ArtifactsBusinessLogic arb = getTestSubject();
1549 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1550 Either<Boolean, ResponseFormat> result;
1553 testSubject = createTestSubject();
1554 result = Deencapsulation.invoke(testSubject, "validateUserRole",
1555 new Object[]{user, auditingAction, componentId, artifactId, componentType,
1561 public void testDetectAuditingType() throws Exception {
1562 ArtifactsBusinessLogic testSubject;
1563 ArtifactsBusinessLogic arb = getTestSubject();
1564 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1565 String origMd5 = "";
1566 AuditingActionEnum result;
1569 testSubject = createTestSubject();
1570 result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1571 new Object[]{operation, origMd5});
1572 assertNotNull(result);
1576 public void testDetectNoAuditingType() throws Exception {
1577 ArtifactsBusinessLogic testSubject;
1578 ArtifactsBusinessLogic arb = getTestSubject();
1579 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.LINK);
1580 String origMd5 = "";
1581 AuditingActionEnum result;
1584 testSubject = createTestSubject();
1585 result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1586 new Object[]{operation, origMd5});
1591 public void testCreateEsArtifactData() throws Exception {
1592 ArtifactsBusinessLogic testSubject;
1593 ArtifactDataDefinition artifactInfo = buildArtifactPayload();
1594 byte[] artifactPayload = new byte[]{' '};
1595 DAOArtifactData result;
1598 testSubject = createTestSubject();
1599 result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1600 assertNotNull(result);
1605 public void testIsArtifactMetadataUpdateTrue() throws Exception {
1606 ArtifactsBusinessLogic testSubject;
1607 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ARTIFACT_METADATA_UPDATE;
1611 testSubject = createTestSubject();
1612 result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1613 new Object[]{auditingActionEnum});
1614 assertThat(result).isTrue();
1618 public void testIsArtifactMetadataUpdateFalse() throws Exception {
1619 ArtifactsBusinessLogic testSubject;
1620 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1624 testSubject = createTestSubject();
1625 result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1626 new Object[]{auditingActionEnum});
1627 assertThat(result).isFalse();
1631 public void testIsDeploymentArtifactTrue() throws Exception {
1632 ArtifactsBusinessLogic testSubject;
1633 ArtifactDefinition artifactInfo = buildArtifactPayload();
1634 artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1638 testSubject = createTestSubject();
1639 result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1640 assertThat(result).isTrue();
1644 public void testIsDeploymentArtifactFalse() throws Exception {
1645 ArtifactsBusinessLogic testSubject;
1646 ArtifactDefinition artifactInfo = buildArtifactPayload(); // artifactGroupType == ArtifactGroupTypeEnum.TOSCA
1650 testSubject = createTestSubject();
1651 result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1652 assertThat(result).isFalse();
1656 public void testSetArtifactPlaceholderCommonFields() throws Exception {
1657 ArtifactsBusinessLogic testSubject;
1658 String resourceId = ES_ARTIFACT_ID;
1660 ArtifactDefinition artifactInfo = buildArtifactPayload();
1663 testSubject = createTestSubject();
1664 Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1665 resourceId, user, artifactInfo);
1666 assertEquals(resourceId + "." + ARTIFACT_LABEL, artifactInfo.getUniqueId());
1667 assertEquals(user.getFullName(), artifactInfo.getCreatorFullName());
1672 public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1673 ArtifactsBusinessLogic testSubject;
1674 ArtifactDefinition artifactDefinition = buildArtifactPayload();
1675 String payloadStr = "";
1676 Either<DAOArtifactData, ResponseFormat> result;
1679 testSubject = createTestSubject();
1680 result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1681 new Object[]{artifactDefinition, payloadStr});
1682 assertThat(result.isLeft()).isTrue();
1686 public void testUpdateArtifactOnGroupInstance() throws Exception {
1687 ArtifactsBusinessLogic testSubject;
1688 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1689 Component component = createResourceObject(true);
1690 String instanceId = "";
1691 String prevUUID = "";
1692 ArtifactDefinition artifactInfo = buildArtifactPayload();
1693 Either<ArtifactDefinition, ResponseFormat> result;
1696 testSubject = createTestSubject();
1697 result = testSubject.updateArtifactOnGroupInstance(component, instanceId, prevUUID, artifactInfo, artifactInfo);
1698 assertThat(result.isLeft()).isTrue();
1702 public void testGenerateHeatEnvPayload() throws Exception {
1703 ArtifactsBusinessLogic testSubject;
1704 ArtifactDefinition artifactDefinition = buildArtifactPayload();
1708 testSubject = createTestSubject();
1709 result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1710 new Object[]{artifactDefinition});
1711 assertThat(result.isEmpty()).isFalse();
1716 public void testBuildJsonForUpdateArtifact() throws Exception {
1717 ArtifactsBusinessLogic testSubject;
1718 ArtifactDefinition artifactInfo = buildArtifactPayload();
1719 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1720 List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1721 Map<String, Object> result;
1724 testSubject = createTestSubject();
1725 result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1726 assertThat(MapUtils.isNotEmpty(result)).isTrue();
1730 public void testBuildJsonForUpdateArtifact_1() throws Exception {
1731 ArtifactsBusinessLogic testSubject;
1732 String artifactId = "";
1733 String artifactName = "";
1734 String artifactType = "";
1735 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1737 String displayName = "";
1738 String description = "";
1739 byte[] artifactContent = new byte[]{' '};
1740 List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1741 List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1742 Map<String, Object> result;
1745 testSubject = createTestSubject();
1747 result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1748 label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1749 assertThat(MapUtils.isNotEmpty(result)).isTrue();
1754 public void testNotReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1755 ArtifactsBusinessLogic testSubject;
1756 List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1757 List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1760 testSubject = createTestSubject();
1761 boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue",
1762 new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1763 assertThat(result).isFalse();
1768 public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1769 ArtifactsBusinessLogic testSubject;
1770 HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1771 hpdOrig.setName("param1");
1772 hpdOrig.setCurrentValue("value1");
1774 HeatParameterDefinition hpdUpd = new HeatParameterDefinition();
1775 hpdUpd.setName("param1");
1776 hpdUpd.setCurrentValue("value2");
1778 List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1779 currentHeatEnvParams.add(hpdOrig);
1781 List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1782 updatedHeatEnvParams.add(hpdUpd);
1785 testSubject = createTestSubject();
1786 boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue",
1787 new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1788 assertThat(result).isTrue();
1789 assertEquals(hpdUpd.getCurrentValue(), hpdOrig.getCurrentValue());
1794 public void testExtractArtifactDefinition() throws Exception {
1795 ArtifactsBusinessLogic testSubject;
1796 ArtifactDefinition artifactDefinition = buildArtifactPayload();
1797 Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1798 ArtifactDefinition result;
1801 testSubject = createTestSubject();
1802 result = testSubject.extractArtifactDefinition(eitherArtifact);
1803 assertNotNull(result);
1804 assertEquals(artifactDefinition, result);
1809 public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1810 ArtifactsBusinessLogic testSubject;
1811 ArtifactDefinition artifact = buildArtifactPayload();
1812 ArtifactDefinition artifactInfo = new ArtifactDefinition();
1814 HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1815 hpdOrig.setName("param1");
1816 hpdOrig.setCurrentValue("value1");
1817 List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1818 currentHeatEnvParams.add(hpdOrig);
1819 artifact.setListHeatParameters(currentHeatEnvParams);
1822 testSubject = createTestSubject();
1823 Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1824 artifact, artifactInfo);
1826 assertNotEquals(artifact, artifactInfo);
1827 assertEquals(1, artifact.getListHeatParameters().size());
1828 assertEquals(1, artifactInfo.getListHeatParameters().size());
1830 String hpdOrigCurrValue = artifact.getListHeatParameters().get(0).getCurrentValue();
1831 String hpdNewDefaultValue = artifactInfo.getListHeatParameters().get(0).getDefaultValue();
1833 assertEquals(hpdOrigCurrValue, hpdNewDefaultValue);
1837 public void testBuildHeatEnvFileNameArtifactNameNotNull() throws Exception {
1838 String heatEnvExt = "zip";
1839 ArtifactsBusinessLogic testSubject;
1840 ArtifactDefinition heatArtifact = buildArtifactPayload();
1841 ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1842 Map<String, Object> placeHolderData = new HashMap<>();
1843 placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1844 String artName = ARTIFACT_NAME.split("\\.")[0];
1847 testSubject = createTestSubject();
1848 Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1849 assertThat(heatEnvArtifact.getArtifactName().startsWith(artName)).isTrue();
1850 assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1854 public void testBuildHeatEnvFileNameArtifactNameIsNull() throws Exception {
1855 String heatEnvExt = "zip";
1856 ArtifactsBusinessLogic testSubject;
1857 ArtifactDefinition heatArtifact = buildArtifactPayload();
1858 heatArtifact.setArtifactName(null);
1859 ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1860 Map<String, Object> placeHolderData = new HashMap<>();
1861 placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1864 testSubject = createTestSubject();
1865 Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1866 assertThat(heatEnvArtifact.getArtifactName().startsWith(ARTIFACT_LABEL)).isTrue();
1867 assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1871 public void testHandleEnvArtifactVersion() throws Exception {
1872 ArtifactsBusinessLogic testSubject;
1873 String existingVersion = "1.0";
1874 ArtifactDefinition artifactInfo = buildArtifactPayload();
1875 Map<String, String> existingEnvVersions = new HashMap<>();
1876 existingEnvVersions.put(artifactInfo.getArtifactName(), existingVersion);
1879 testSubject = createTestSubject();
1880 Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", artifactInfo, existingEnvVersions);
1881 assertEquals(existingVersion, artifactInfo.getArtifactVersion());
1885 public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1886 ArtifactsBusinessLogic testSubject;
1887 List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();
1888 Resource component = createResourceObject(true);
1890 List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();
1891 ArtifactsBusinessLogic arb = getTestSubject();
1892 ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1893 boolean shouldLock = false;
1894 boolean inTransaction = false;
1895 List<ArtifactDefinition> result;
1898 testSubject = createTestSubject();
1899 result = testSubject.handleArtifactsForInnerVfcComponent(artifactsToHandle, component, user,
1900 vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1902 assertThat(CollectionUtils.isEmpty(result)).isTrue();
1906 public void testSetNodeTemplateOperation() throws Exception {
1907 ArtifactsBusinessLogic testSubject;
1908 NodeTemplateOperation nodeTemplateOperation = new NodeTemplateOperation();
1911 testSubject = createTestSubject();
1912 Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", nodeTemplateOperation);
1913 assertEquals(Deencapsulation.getField(testSubject, "nodeTemplateOperation"), nodeTemplateOperation);
1917 @Test(expected = ComponentException.class)
1918 public void validateDeploymentArtifact_invalidComponentType() {
1919 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1920 Component component = new Resource();
1921 component.setComponentType(ComponentTypeEnum.PRODUCT);
1922 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1924 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1927 @Test(expected = ComponentException.class)
1928 public void validateDeploymentArtifact_notConfiguredArtifactType() {
1929 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1930 Component component = new Resource();
1931 component.setComponentType(ComponentTypeEnum.RESOURCE);
1932 artifactDefinition.setArtifactType("NotConfiguredType");
1933 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1935 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1938 @Test(expected = ComponentException.class)
1939 public void validateDeploymentArtifact_unsupportedResourceType() {
1940 final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1941 artifactDefinition.setArtifactType(ArtifactTypeEnum.ANSIBLE_PLAYBOOK.getType());
1942 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1943 final Resource resourceComponent = new Resource();
1944 resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1945 resourceComponent.setResourceType(ResourceTypeEnum.ServiceProxy);
1946 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1948 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1952 public void validateDeploymentArtifact_validArtifact() {
1953 final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1954 artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
1955 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1956 final Resource resourceComponent = new Resource();
1957 resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1958 resourceComponent.setResourceType(ResourceTypeEnum.VF);
1959 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1960 assertThatCode(() -> {
1962 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1963 }).doesNotThrowAnyException();
1968 public void validateHeatArtifact_validArtifact() {
1969 final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1970 artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
1971 artifactDefinition.setTimeout(1);
1972 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1973 assertThatCode(() -> {
1975 .invoke(artifactsBusinessLogic, "validateHeatArtifact", new Resource(), "componentId", artifactDefinition);
1976 }).doesNotThrowAnyException();
1980 public void validateInputForResourceInstance() {
1981 final String artifactId = "artifactId";
1982 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1983 artifactDefinition.setUniqueId(artifactId);
1984 artifactDefinition.setArtifactName(ARTIFACT_NAME);
1985 artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
1986 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
1987 artifactDefinition.setEsId(ES_ARTIFACT_ID);
1988 artifactDefinition.setPayload(PAYLOAD);
1989 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1990 artifactDefinition.setDescription("artifact description");
1991 artifactDefinition.setServiceApi(true);
1992 artifactDefinition.setApiUrl("dumbUrl");
1994 final User user = new User();
1995 user.setUserId("userId");
1996 user.setRole(Role.ADMIN.name());
1998 final String parentId = "parentId";
1999 final Service service = new Service();
2000 service.setComponentType(ComponentTypeEnum.SERVICE);
2001 service.setUniqueId(parentId);
2002 service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2003 service.setLastUpdaterUserId(user.getUserId());
2005 final ArtifactOperationInfo operationInfo =
2006 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2008 final String componentId = "componentId";
2009 final ComponentInstance componentInstance = new ComponentInstance();
2010 componentInstance.setUniqueId(componentId);
2011 componentInstance.setComponentUid(componentId);
2012 service.setComponentInstances(Collections.singletonList(componentInstance));
2014 final Resource resource = new Resource();
2015 when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2016 when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2018 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2019 artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2020 Object result = Deencapsulation
2021 .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2022 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2023 assertTrue(result instanceof Either<?, ?>);
2024 assertTrue(((Either<?, ?>) result).isLeft());
2026 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2028 result = Deencapsulation
2029 .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2030 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2031 assertTrue(result instanceof Either<?, ?>);
2032 assertTrue(((Either<?, ?>) result).isLeft());
2036 public void validateInputForResourceInstanceDeploymentArtifact() {
2037 final String artifactId = "artifactId";
2038 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2039 artifactDefinition.setUniqueId(artifactId);
2040 artifactDefinition.setArtifactName(ARTIFACT_NAME);
2041 artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
2042 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
2043 artifactDefinition.setEsId(ES_ARTIFACT_ID);
2044 artifactDefinition.setPayload(PAYLOAD);
2045 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2046 artifactDefinition.setDescription("artifact description");
2048 final User user = new User();
2049 user.setUserId("userId");
2050 user.setRole(Role.ADMIN.name());
2052 final String parentId = "parentId";
2053 final Service service = new Service();
2054 service.setComponentType(ComponentTypeEnum.SERVICE);
2055 service.setUniqueId(parentId);
2056 service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2057 service.setLastUpdaterUserId(user.getUserId());
2059 final ArtifactOperationInfo operationInfo =
2060 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2062 final String componentId = "componentId";
2063 final ComponentInstance componentInstance = new ComponentInstance();
2064 componentInstance.setUniqueId(componentId);
2065 componentInstance.setComponentUid(componentId);
2066 service.setComponentInstances(Collections.singletonList(componentInstance));
2068 final Resource resource = new Resource();
2069 when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2070 when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2072 final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2073 artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2075 final Object result = Deencapsulation
2076 .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2077 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2078 assertTrue(result instanceof Either<?, ?>);
2079 assertTrue(((Either<?, ?>) result).isLeft());
2084 public void testHandleArtifactRequest() {
2086 String componentId = "componentId";
2087 ArtifactOperationInfo operationInfo = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE);
2088 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2089 artifactDefinition.setArtifactName("other");
2090 artifactDefinition.setUniqueId("artifactId");
2091 artifactDefinition.setPayload("Test".getBytes());
2092 artifactDefinition.setArtifactLabel("other");
2093 artifactDefinition.setDescription("Test artifact");
2094 artifactDefinition.setArtifactType(ArtifactTypeEnum.OTHER.getType());
2095 artifactDefinition.setArtifactUUID("artifactUId");
2096 artifactDefinition.setArtifactLabel("test");
2097 artifactDefinition.setArtifactDisplayName("Test");
2098 artifactDefinition.setEsId("esId");
2100 String requestMd5 = GeneralUtility.calculateMD5Base64EncodedByString("data");
2101 User user = new User();
2102 user.setUserId("userId");
2104 List<ComponentInstance> componentInstanceList = new ArrayList<>();
2105 List<InterfaceDefinition> interfaceDefinitionsList = new ArrayList<>();
2106 Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2107 Map<String, Operation> operationsMap = new HashMap<>();
2108 artifactDefinitionMap.put("sample", artifactDefinition);
2110 ComponentInstance componentInstance = new ComponentInstance();
2111 componentInstance.setUniqueId(componentId);
2112 componentInstance.setDeploymentArtifacts(artifactDefinitionMap);
2113 componentInstanceList.add(componentInstance);
2115 Operation operation = new Operation();
2116 operation.setUniqueId("ouuid");
2117 operation.setName("operation1");
2118 operation.setImplementation(artifactDefinition);
2119 operationsMap.put("op1", operation);
2121 Map<String, InterfaceDefinition> interfaceDefinitions = new HashMap<>();
2123 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2124 interfaceDefinition.setType("iuuid");
2125 interfaceDefinition.setOperationsMap(operationsMap);
2126 interfaceDefinitions.put("iuuid", interfaceDefinition);
2128 interfaceDefinitionsList.add(interfaceDefinition);
2130 ResourceMetadataDataDefinition resourceMetadaData = new ResourceMetadataDataDefinition();
2131 resourceMetadaData.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
2132 resourceMetadaData.setLastUpdaterUserId(user.getUserId());
2133 Resource resource = new Resource(new ResourceMetadataDefinition(resourceMetadaData));
2134 resource.setComponentInstances(componentInstanceList);
2135 resource.setUniqueId(componentId);
2136 resource.setInterfaces(interfaceDefinitions);
2138 user.setRole(Role.ADMIN.name());
2140 when(userValidations.validateUserExists(Mockito.eq("userId")))
2142 when(userValidations.isSameUser(Mockito.eq("userId"), Mockito.eq("userId")))
2144 when(toscaOperationFacade.getToscaFullElement(any()))
2145 .thenReturn(Either.left(resource));
2146 when(artifactToscaOperation.getArtifactById(any(), any(), any(), any()))
2147 .thenReturn(Either.left(artifactDefinition));
2148 when(artifactsResolver.findArtifactOnComponent(any(), any(ComponentTypeEnum.class), anyString()))
2149 .thenReturn(artifactDefinition);
2150 when(graphLockOperation.lockComponent(eq(resource.getUniqueId()), any(NodeTypeEnum.class)))
2151 .thenReturn(StorageOperationStatus.OK);
2152 when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), anyString(), any(NodeTypeEnum.class), any(),
2154 .thenReturn(Either.left(artifactDefinition));
2155 when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class))).thenReturn(CassandraOperationStatus.OK);
2156 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
2157 when(interfaceOperation.updateInterfaces(any(Component.class), anyList())).thenReturn(Either.left(interfaceDefinitionsList));
2158 when(artifactToscaOperation.getAllInstanceArtifacts(resource.getUniqueId(), componentId)).thenReturn(Either.left(artifactDefinitionMap));
2159 when(toscaOperationFacade.generateCustomizationUUIDOnInstance(any(), any())).thenReturn(StorageOperationStatus.OK);
2161 Either<ArtifactDefinition, Operation> result = artifactBL.handleArtifactRequest(componentId, user.getUserId(),
2162 ComponentTypeEnum.RESOURCE_INSTANCE
2163 , operationInfo, artifactDefinition.getUniqueId(), artifactDefinition, requestMd5, "data", "iuuid",
2164 null, componentId, "resources");
2166 assertThat(result.isLeft()).isTrue();
2167 ArtifactDefinition leftValue = result.left().value();
2168 assertEquals(artifactDefinition.getArtifactName(), leftValue.getArtifactName());
2172 public void testGenerateToscaArtifact() {
2174 Resource resource = new Resource();
2175 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2176 resource.setUniqueId("resourceId");
2178 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2179 artifactDefinition.setUniqueId("artifactId");
2180 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_CSAR.getType());
2181 User user = new User();
2182 boolean inCertificationRequest = false;
2183 boolean fetchTemplatesFromDB = false;
2184 boolean shouldLock = false;
2185 boolean inTransaction = false;
2187 byte[] csar = "test.csar".getBytes();
2189 when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2190 .thenReturn(Either.left(csar));
2192 artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(Component.class), anyString(), any(NodeTypeEnum.class),
2193 anyString(), anyBoolean()))
2194 .thenReturn(Either.left(artifactDefinition));
2195 when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
2196 .thenReturn(CassandraOperationStatus.OK);
2198 Either<ArtifactDefinition, Operation> result
2199 = artifactBL.generateAndSaveToscaArtifact(artifactDefinition, resource, user, inCertificationRequest,
2200 shouldLock, inTransaction, fetchTemplatesFromDB);
2202 Assert.assertEquals(artifactDefinition.getUniqueId(), result.left().value().getUniqueId());
2206 public void testHandleDownloadToscaModelRequest() {
2207 ArtifactsBusinessLogic testSubject = getTestSubject();
2208 byte[] generatedCsar = "test.csar".getBytes();
2210 Resource resource = new Resource();
2211 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2213 ArtifactDefinition csarArtifact = new ArtifactDefinition();
2214 csarArtifact.setArtifactName("csarArtifact");
2215 csarArtifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.getType());
2216 csarArtifact.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2218 when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2219 .thenReturn(Either.left(generatedCsar));
2221 ImmutablePair<String, byte[]> result =
2222 testSubject.handleDownloadToscaModelRequest(resource, csarArtifact);
2224 assertEquals(csarArtifact.getArtifactName(), result.getKey());
2228 public void testHandleDownloadRequestById_returnsSuccessful() {
2229 String componentId = "componentId";
2230 String artifactId = "artifactId";
2231 String parentId = "parentId";
2233 DAOArtifactData daoArtifactData = new DAOArtifactData();
2234 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2235 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2236 Operation operation = new Operation();
2237 operation.setUniqueId("op1");
2239 artifactDefinition.setArtifactName("test.csar");
2240 artifactDefinition.setArtifactType(ComponentTypeEnum.RESOURCE.name());
2241 artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
2242 artifactDefinition.setUniqueId(artifactId);
2243 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2245 daoArtifactData.setDataAsArray("data".getBytes());
2247 Resource resource = new Resource();
2248 resource.setUniqueId("resourceId");
2249 resource.setAbstract(false);
2251 Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2252 Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
2253 interfaceDefinitionMap.put("interDef1", interfaceDefinition);
2255 artifactDefinitionMap.put("artifact1", artifactDefinition);
2257 resource.setDeploymentArtifacts(artifactDefinitionMap);
2259 User user = new User();
2260 user.setUserId("userId");
2262 when(userValidations.validateUserExists(eq(user.getUserId())))
2264 when(userValidations.isSameUser(Mockito.eq("userId"), Mockito.eq("userId")))
2266 when(toscaOperationFacade.getToscaFullElement(eq(componentId)))
2267 .thenReturn(Either.left(resource));
2268 when(artifactToscaOperation.getArtifactById(anyString(), anyString(), any(ComponentTypeEnum.class), anyString()))
2269 .thenReturn(Either.left(artifactDefinition));
2270 when(artifactCassandraDao.getArtifact(any()))
2271 .thenReturn(Either.left(daoArtifactData));
2272 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
2274 ImmutablePair<String, byte[]> result =
2275 artifactBL.handleDownloadRequestById(componentId, artifactId, user.getUserId(), ComponentTypeEnum.RESOURCE,
2277 Assert.assertEquals(artifactDefinition.getArtifactName(), result.getKey());
2281 public void testHandleDownloadRequestById_givenUserIdIsNull_thenReturnsError() {
2282 String componentId = "componentId";
2283 String userId = null;
2284 String artifactId = "artifactId";
2287 ImmutablePair<String, byte[]> result =
2288 artifactBL.handleDownloadRequestById(componentId, artifactId, userId, ComponentTypeEnum.RESOURCE, componentId
2290 } catch (ComponentException e) {
2291 assertEquals(e.getActionStatus(), ActionStatus.MISSING_INFORMATION);
2298 public void testHandleGetArtifactByType_returnsSuccessful() {
2299 String parentId = "parentId";
2300 String componentId = "componentId";
2301 String artifactGroupType = ArtifactGroupTypeEnum.OTHER.name();
2302 String userId = "userId";
2304 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2305 artifactDefinition.setArtifactName("test.csar");
2307 Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2308 artifactDefinitionMap.put("artifact1", artifactDefinition);
2310 Service service = new Service();
2311 service.setUniqueId(componentId);
2313 when(toscaOperationFacade.getToscaElement(eq(componentId), any(ComponentParametersView.class)))
2314 .thenReturn(Either.left(service));
2315 when(graphLockOperation.lockComponent(eq(componentId), any(NodeTypeEnum.class)))
2316 .thenReturn(StorageOperationStatus.OK);
2317 when(artifactToscaOperation.getArtifacts(any(), any(NodeTypeEnum.class), any(ArtifactGroupTypeEnum.class), any()))
2318 .thenReturn(Either.left(artifactDefinitionMap));
2320 Map<String, ArtifactDefinition> result =
2321 artifactBL.handleGetArtifactsByType(ComponentTypeEnum.SERVICE.name(), parentId, ComponentTypeEnum.SERVICE,
2322 componentId, artifactGroupType, userId);
2323 Assert.assertEquals(artifactDefinition.getArtifactName(), result.get("artifact1").getArtifactName());
2327 public void testGetDeployment_returnsSuccessful() {
2329 Resource resource = new Resource();
2330 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2331 ComponentInstance componentInstance = new ComponentInstance();
2332 NodeTypeEnum parentType = NodeTypeEnum.ResourceInstance;
2333 String ciId = "ciId";
2335 artifactDefinition.setArtifactName("test.csar");
2336 componentInstance.setUniqueId(ciId);
2337 List<ComponentInstance> componentInstanceList = new ArrayList<>();
2338 componentInstanceList.add(componentInstance);
2340 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2341 deploymentArtifacts.put("test.csar", artifactDefinition);
2343 resource.setDeploymentArtifacts(deploymentArtifacts);
2344 resource.setComponentInstances(componentInstanceList);
2345 componentInstance.setDeploymentArtifacts(deploymentArtifacts);
2347 List<ArtifactDefinition> result = artifactBL.getDeploymentArtifacts(resource, ciId);
2348 assertThat(result.size() == 1).isTrue();
2349 Assert.assertEquals(artifactDefinition.getArtifactName(), result.get(0).getArtifactName());
2353 public void testHandleDelete_returnsSuccessful() {
2355 String parentId = "parentId";
2356 String artifactId = "artifactId";
2357 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2358 Resource resource = new Resource();
2359 User user = new User();
2361 artifactDefinition.setArtifactName("test.csar");
2362 artifactDefinition.setUniqueId(artifactId);
2363 artifactDefinition.setEsId("esId");
2365 ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
2367 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2368 deploymentArtifacts.put(artifactId, artifactDefinition);
2370 resource.setUniqueId(parentId);
2371 resource.setComponentType(ComponentTypeEnum.RESOURCE);
2372 resource.setDeploymentArtifacts(deploymentArtifacts);
2374 when(graphLockOperation.lockComponent(eq(parentId), any(NodeTypeEnum.class)))
2375 .thenReturn(StorageOperationStatus.OK);
2376 when(toscaOperationFacade.getToscaElement(eq(parentId)))
2377 .thenReturn(Either.left(resource));
2378 when(artifactToscaOperation.isCloneNeeded(any(), any(ArtifactDefinition.class), any(NodeTypeEnum.class)))
2379 .thenReturn(Either.left(Boolean.FALSE));
2380 when(artifactToscaOperation.removeArtifactOnGraph(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class), anyBoolean()))
2381 .thenReturn(Either.left(artifactDataDefinition));
2382 when(artifactCassandraDao.deleteArtifact(any()))
2383 .thenReturn(CassandraOperationStatus.OK);
2385 Either<ArtifactDefinition, ResponseFormat> result = artifactBL.handleDelete(
2386 parentId, artifactId, user, resource, true, false);
2387 Assert.assertEquals(artifactDefinition.getArtifactName(), result.left().value().getArtifactName());
2391 public void testDownloadRsrcArtifactByNames_givenServiceNameNull_thenReturnsError() {
2392 String serviceName = null;
2393 String serviceVersion = "2.0";
2394 String resourceName = "resource";
2395 String resourceVersion = "1.0";
2396 String artifactName = "artifactName";
2399 artifactBL.downloadRsrcArtifactByNames(serviceName, serviceVersion, resourceName, resourceVersion, artifactName);
2400 } catch (ComponentException e) {
2401 assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
2409 public void testDownloadRsrcArtifactByNames_returnsSuccessful() {
2411 String serviceName = "service1";
2412 String resourceName = "resource1";
2413 String artifactName = "artifact1";
2414 String version = "1.0";
2416 Resource resource = new Resource();
2417 resource.setName(resourceName);
2418 resource.setVersion(version);
2420 Service service = new Service();
2421 service.setVersion(version);
2422 service.setName(serviceName);
2424 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2425 artifactDefinition.setEsId("esId");
2427 DAOArtifactData esArtifactData = new DAOArtifactData();
2428 esArtifactData.setDataAsArray("test".getBytes());
2430 artifactDefinition.setArtifactName(artifactName);
2431 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2432 artifacts.put(artifactName, artifactDefinition);
2433 resource.setDeploymentArtifacts(artifacts);
2435 when(toscaOperationFacade.getComponentByNameAndVersion(eq(ComponentTypeEnum.RESOURCE), eq(resourceName), eq(version),
2436 eq(JsonParseFlagEnum.ParseMetadata)))
2437 .thenReturn(Either.left(resource));
2438 doReturn(Either.left(service)).when(toscaOperationFacade).getBySystemNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, version);
2439 when(artifactCassandraDao.getArtifact(any())).thenReturn(Either.left(esArtifactData));
2441 byte[] result = artifactBL.downloadRsrcArtifactByNames(serviceName, version, resourceName, version, artifactName);
2442 Assert.assertEquals(esArtifactData.getDataAsArray(), result);
2445 private ArtifactsBusinessLogic getTestSubject() {
2446 final ArtifactsBusinessLogic artifactsBusinessLogic = new ArtifactsBusinessLogic(artifactCassandraDao,
2447 toscaExportHandler, csarUtils, lifecycleBusinessLogic,
2448 userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation,
2450 interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation, artifactTypeOperation);
2451 artifactsBusinessLogic.setComponentsUtils(componentsUtils);
2452 return artifactsBusinessLogic;