catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.components.impl;
  24
  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;
  46
  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;
  61 import java.util.Map;
  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.JanusGraphOperationStatus;
  97 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  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.UserAdminOperation;
 132 import org.openecomp.sdc.be.resources.data.DAOArtifactData;
 133 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 134 import org.openecomp.sdc.be.servlets.RepresentationUtils;
 135 import org.openecomp.sdc.be.tosca.CsarUtils;
 136 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
 137 import org.openecomp.sdc.be.user.Role;
 138 import org.openecomp.sdc.be.user.UserBusinessLogic;
 139 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 140 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
 141 import org.openecomp.sdc.common.datastructure.Wrapper;
 142 import org.openecomp.sdc.common.util.GeneralUtility;
 143 import org.openecomp.sdc.exception.ResponseFormat;
 144
 145 @RunWith(MockitoJUnitRunner.Silent.class)
 146 public class ArtifactsBusinessLogicTest extends BaseBusinessLogicMock {
 147
 148     private static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN",
 149             System.currentTimeMillis());
 150     private static final String RESOURCE_INSTANCE_NAME = "Service-111";
 151     private static final String INSTANCE_ID = "S-123-444-ghghghg";
 152     private static final String ARTIFACT_NAME = "service-Myservice-template.yml";
 153     private static final String ARTIFACT_LABEL = "assettoscatemplate";
 154     private static final String ES_ARTIFACT_ID = "123123dfgdfgd0";
 155     private static final byte[] PAYLOAD = "some payload".getBytes();
 156     private static final String RESOURCE_NAME = "My-Resource_Name with   space";
 157     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 158     private static final String RESOURCE_SUBCATEGORY = "Router";
 159     private static final String ARTIFACT_PLACEHOLDER_FILE_EXTENSION = "fileExtension";
 160     public static final Resource resource = Mockito.mock(Resource.class);
 161
 162     @InjectMocks
 163     private ArtifactsBusinessLogic artifactBL;
 164     private static User user = null;
 165     private static Resource resourceResponse = null;
 166     final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 167     @Mock
 168     public ComponentsUtils componentsUtils;
 169     @Mock
 170     public ToscaOperationFacade toscaOperationFacade;
 171     JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
 172     @Mock
 173     JanusGraphDao janusGraphDao;
 174     @Mock
 175     private UserBusinessLogic userBusinessLogic;
 176     @Mock
 177     private ArtifactOperation artifactOperation;
 178     @Mock
 179     private IInterfaceLifecycleOperation lifecycleOperation;
 180     @Mock
 181     private UserAdminOperation userOperation;
 182     @Mock
 183     private IElementOperation elementOperation;
 184     @Mock
 185     private ArtifactCassandraDao artifactCassandraDao;
 186     @Mock
 187     private NodeTemplateOperation nodeTemplateOperation;
 188     @Mock
 189     private IGraphLockOperation graphLockOperation;
 190     @Mock
 191     private UserValidations userValidations;
 192     @Mock
 193     private ArtifactsResolver artifactsResolver;
 194     @Mock
 195     private CsarUtils csarUtils;
 196     @Mock
 197     private ToscaExportHandler toscaExportHandler;
 198     @Mock
 199     private LifecycleBusinessLogic lifecycleBusinessLogic;
 200     private Gson gson = new GsonBuilder().setPrettyPrinting().create();
 201
 202     private static List<ArtifactType> getAllTypes() {
 203         final List<ArtifactConfiguration> artifactConfigurationList = ConfigurationManager.getConfigurationManager()
 204             .getConfiguration().getArtifacts();
 205         return artifactConfigurationList.stream().map(artifactConfiguration -> {
 206             final ArtifactType artifactType = new ArtifactType();
 207             artifactType.setName(artifactConfiguration.getType());
 208             return artifactType;
 209         }).collect(Collectors.toList());
 210     }
 211
 212     @Before
 213     public void initMocks() {
 214         MockitoAnnotations.initMocks(this);
 215         Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
 216                 .right(StorageOperationStatus.NOT_FOUND);
 217
 218         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either
 219                 .right(StorageOperationStatus.NOT_FOUND);
 220         when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Service), Mockito.anyBoolean()))
 221                 .thenReturn(NotFoundResult2);
 222         when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Resource), Mockito.anyBoolean()))
 223                 .thenReturn(NotFoundResult2);
 224
 225         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
 226                 .right(StorageOperationStatus.NOT_FOUND);
 227         when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
 228                 .thenReturn(notFoundInterfaces);
 229
 230                 when(userOperation.getUserData("jh0003", false)).thenReturn(Either.left(USER));
 231
 232         when(elementOperation.getAllArtifactTypes()).thenReturn(getAllTypes());
 233
 234         when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
 235
 236         // User data and management
 237         user = new User();
 238         user.setUserId("jh0003");
 239         user.setFirstName("Jimmi");
 240         user.setLastName("Hendrix");
 241         user.setRole(Role.ADMIN.name());
 242
 243         // createResource
 244         resourceResponse = createResourceObject(true);
 245         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 246         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 247         when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(StorageOperationStatus.OK);
 248         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
 249         when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 250         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 251
 252         Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
 253                 .right(StorageOperationStatus.BAD_REQUEST);
 254         when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
 255                 .thenReturn(resourceStorageOperationStatusEither);
 256     }
 257
 258     @Test
 259     public void testValidJson() {
 260         ArtifactDefinition ad = createArtifactDef();
 261
 262         String jsonArtifact = "";
 263
 264         ObjectMapper mapper = new ObjectMapper();
 265         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 266         mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 267         mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 268
 269         try {
 270             jsonArtifact = mapper.writeValueAsString(ad);
 271         } catch (IOException e) {
 272             // TODO Auto-generated catch block
 273             e.printStackTrace();
 274         }
 275
 276         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
 277                 ArtifactDefinition.class, false);
 278         assertEquals(ad, afterConvert);
 279     }
 280
 281     private ArtifactDefinition createArtifactDef() {
 282         ArtifactDefinition ad = new ArtifactDefinition();
 283         ad.setArtifactName("artifact1.yaml");
 284         ad.setArtifactLabel("label1");
 285         ad.setDescription("description");
 286         ad.setArtifactType(ArtifactTypeEnum.HEAT.getType());
 287         ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 288         ad.setCreationDate(System.currentTimeMillis());
 289         ad.setMandatory(false);
 290         ad.setTimeout(15);
 291         return ad;
 292     }
 293
 294     private Resource createResourceObject(boolean afterCreate) {
 295         Resource resource = new Resource();
 296         resource.setName(RESOURCE_NAME);
 297         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 298         resource.setDescription("My short description");
 299         List<String> tgs = new ArrayList<String>();
 300         tgs.add("test");
 301         tgs.add(resource.getName());
 302         resource.setTags(tgs);
 303         List<String> template = new ArrayList<String>();
 304         template.add("Root");
 305         resource.setDerivedFrom(template);
 306         resource.setVendorName("Motorola");
 307         resource.setVendorRelease("1.0.0");
 308         resource.setContactId("ya5467");
 309         resource.setIcon("MyIcon");
 310
 311         if (afterCreate) {
 312             resource.setName(resource.getName());
 313             resource.setVersion("0.1");
 314             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 315             resource.setCreatorUserId(user.getUserId());
 316             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 317             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 318         }
 319         return resource;
 320     }
 321
 322     @Test
 323     public void testUpdateCIDeploymentArtifactTimeout() {
 324         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 325         ArtifactDefinition envArtifact = new ArtifactDefinition();
 326         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 327         ComponentInstance ci = new ComponentInstance();
 328         ci.setUniqueId("ciid");
 329         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
 330         GroupInstance groupInstance = new GroupInstance();
 331         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 332         groupInstance.setCustomizationUUID("custUid");
 333         groupInstance.setUniqueId("guid");
 334         List<GroupInstance> groupInstances = new ArrayList<>();
 335         groupInstances.addAll(Arrays.asList(groupInstance));
 336         ci.setGroupInstances(groupInstances);
 337         Service service = new Service();
 338         service.setComponentInstances(Collections.singletonList(ci));
 339         service.setUniqueId("suid");
 340
 341         when (artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
 342                 heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(Either.left(heatArtifact));
 343         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 344                 .thenReturn(StorageOperationStatus.OK);
 345         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
 346                 .thenReturn(Either.left(new ArrayList()));
 347         when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(), new ArrayList<>(Arrays.asList("guid"))))
 348                 .thenReturn(StorageOperationStatus.OK);
 349         artifactBL.handleUpdate(ci.getUniqueId(),ComponentTypeEnum.RESOURCE_INSTANCE,
 350             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 351                 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 352         assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(envArtifact.getTimeout());
 353         assertThat(ci.getDeploymentArtifacts().get("HEAT_ENV").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
 354     }
 355
 356     @Test
 357     public void testUpdateCIDeploymentTimeout_invalidTimeout() {
 358         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 359         ArtifactDefinition envArtifact = new ArtifactDefinition();
 360         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 361         ComponentInstance ci = new ComponentInstance();
 362         ci.setUniqueId("ciid");
 363         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
 364         GroupInstance groupInstance = new GroupInstance();
 365         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 366         groupInstance.setCustomizationUUID("custUid");
 367         groupInstance.setUniqueId("guid");
 368         List<GroupInstance> groupInstances = new ArrayList<>();
 369         groupInstances.addAll(Arrays.asList(groupInstance));
 370         ci.setGroupInstances(groupInstances);
 371         Service service = new Service();
 372         service.setComponentInstances(Collections.singletonList(ci));
 373         service.setUniqueId("suid");
 374         envArtifact.setTimeout(130);
 375
 376         when (artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
 377                 heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(Either.left(heatArtifact));
 378         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 379                 .thenReturn(StorageOperationStatus.OK);
 380         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
 381                 .thenReturn(Either.left(new ArrayList()));
 382         when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(), new ArrayList<>(Arrays.asList("guid"))))
 383                 .thenReturn(StorageOperationStatus.OK);
 384         try {
 385             artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 386                     "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 387         } catch (ComponentException exp) {
 388             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
 389             return;
 390         }
 391         fail();
 392     }
 393
 394     @Test
 395     public void testUpdateCIDeploymentTimeout_negativeTimeout() {
 396         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 397         ArtifactDefinition envArtifact = new ArtifactDefinition();
 398         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 399         ComponentInstance ci = new ComponentInstance();
 400         ci.setUniqueId("ciid");
 401         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
 402         GroupInstance groupInstance = new GroupInstance();
 403         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 404         groupInstance.setCustomizationUUID("custUid");
 405         groupInstance.setUniqueId("guid");
 406         List<GroupInstance> groupInstances = new ArrayList<>();
 407         groupInstances.addAll(Arrays.asList(groupInstance));
 408         ci.setGroupInstances(groupInstances);
 409         Service service = new Service();
 410         service.setComponentInstances(Collections.singletonList(ci));
 411         service.setUniqueId("suid");
 412         envArtifact.setTimeout(-1);
 413
 414         when (artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
 415                 heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(Either.left(heatArtifact));
 416         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 417                 .thenReturn(StorageOperationStatus.OK);
 418         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
 419                 .thenReturn(Either.left(new ArrayList()));
 420         when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(), new ArrayList<>(Arrays.asList("guid"))))
 421                 .thenReturn(StorageOperationStatus.OK);
 422         try {
 423             artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 424                     "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 425         } catch (ComponentException exp) {
 426             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
 427             return;
 428         }
 429         fail();
 430     }
 431
 432     @Test
 433     public void testUpdateCIDeploymentArtifactTimeout_noUpdate() {
 434         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 435         ArtifactDefinition envArtifact = new ArtifactDefinition();
 436         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 437         ComponentInstance ci = new ComponentInstance();
 438         ci.setUniqueId("ciid");
 439         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
 440         envArtifact.setTimeout(heatArtifact.getTimeout());
 441         GroupInstance groupInstance = new GroupInstance();
 442         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 443         groupInstance.setCustomizationUUID("custUid");
 444         groupInstance.setUniqueId("guid");
 445         List<GroupInstance> groupInstances = new ArrayList<>();
 446         groupInstances.addAll(Arrays.asList(groupInstance));
 447         ci.setGroupInstances(groupInstances);
 448         Service service = new Service();
 449         service.setComponentInstances(Collections.singletonList(ci));
 450         service.setUniqueId("suid");
 451
 452         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 453                 .thenReturn(StorageOperationStatus.OK);
 454         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
 455                 .thenReturn(Either.left(new ArrayList()));
 456         artifactBL.handleUpdate(ci.getUniqueId(),ComponentTypeEnum.RESOURCE_INSTANCE,
 457             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 458                 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 459         assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
 460     }
 461
 462     @Test
 463     public void testUpdateCIDeploymentArtifactTimeout_nonExistingArtifact() {
 464         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 465         ArtifactDefinition envArtifact = new ArtifactDefinition();
 466         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 467         envArtifact.setTimeout(heatArtifact.getTimeout());
 468         envArtifact.setArtifactType("HEAT_ENV");
 469         envArtifact.setGeneratedFromId("uid1");
 470         ComponentInstance ci = new ComponentInstance();
 471         ci.setUniqueId("ciid");
 472         ci.setDeploymentArtifacts(new HashMap<>());
 473         Service service = new Service();
 474         service.setComponentInstances(Collections.singletonList(ci));
 475         service.setUniqueId("suid");
 476
 477         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 478                 .thenReturn(StorageOperationStatus.OK);
 479         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
 480                 .thenReturn(Either.left(new ArrayList()));
 481         assertThatThrownBy(() -> {
 482             artifactBL.handleUpdate(ci.getUniqueId(),ComponentTypeEnum.RESOURCE_INSTANCE,
 483                 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 484                     "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 485         }).isInstanceOf(ComponentException.class);
 486     }
 487
 488     @Test
 489     public void testUpdateCIDeploymentArtifactTimeout_invalidArtifactType() {
 490         ArtifactDefinition envArtifact = new ArtifactDefinition();
 491         envArtifact.setArtifactType("invalid");
 492
 493         try {
 494             artifactBL.handleUpdate("uid", ComponentTypeEnum.RESOURCE_INSTANCE, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 495                     "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, null, true);
 496             fail();
 497         } catch(ComponentException exp) {
 498             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED);
 499             assertThat(exp.getParams()[0]).isEqualTo("invalid");
 500         }
 501     }
 502
 503     private Map<String, ArtifactDefinition> fillDeploymentArtifacts(ArtifactDefinition heatArtifact, ArtifactDefinition envArtifact, ArtifactDefinition origEnvArtifact) {
 504         heatArtifact.setArtifactType("HEAT");
 505         heatArtifact.setTimeout(60);
 506         heatArtifact.setEsId("es");
 507         heatArtifact.setArtifactUUID("uuid1");
 508         heatArtifact.setUniqueId("uid1");
 509         envArtifact.setArtifactUUID("uuid2");
 510         envArtifact.setArtifactType("HEAT_ENV");
 511         envArtifact.setTimeout(30);
 512         envArtifact.setGenerated(true);
 513         envArtifact.setGeneratedFromId("uid1");
 514         envArtifact.setUniqueId("uid2");
 515         origEnvArtifact.setUniqueId("uid2");
 516         origEnvArtifact.setGeneratedFromId("uid1");
 517         origEnvArtifact.setArtifactType("HEAT_ENV");
 518         origEnvArtifact.setTimeout(60);
 519         origEnvArtifact.setGenerated(true);
 520         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 521         deploymentArtifacts.put(heatArtifact.getArtifactType(), heatArtifact);
 522         //deploymentArtifacts.put(envArtifact.getArtifactType(), envArtifact);
 523         deploymentArtifacts.put(envArtifact.getArtifactType(), origEnvArtifact);
 524         return  deploymentArtifacts;
 525     }
 526
 527     @Test
 528     public void testInvalidStringGroupType() {
 529         ArtifactDefinition ad = new ArtifactDefinition();
 530         ad.setArtifactName("artifact1");
 531         ad.setCreationDate(System.currentTimeMillis());
 532         ad.setMandatory(false);
 533         ad.setTimeout(15);
 534
 535         JsonElement jsonArtifact = gson.toJsonTree(ad);
 536         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
 537         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 538         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 539         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 540
 541         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 542                 ArtifactDefinition.class, false);
 543         assertNull(afterConvert);
 544     }
 545
 546     @Test
 547     public void testUpdateArtifactWithEmptyBody() {
 548         try {
 549             RepresentationUtils.convertJsonToArtifactDefinition("", ArtifactDefinition.class, true);
 550             fail();
 551         } catch (ComponentException exp) {
 552             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_BODY);
 553         }
 554     }
 555
 556     @Test
 557     public void testInvalidNumberGroupType() {
 558         ArtifactDefinition ad = new ArtifactDefinition();
 559         ad.setArtifactName("artifact1");
 560         ad.setCreationDate(System.currentTimeMillis());
 561         ad.setMandatory(false);
 562         ad.setTimeout(15);
 563
 564         JsonElement jsonArtifact = gson.toJsonTree(ad);
 565         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
 566         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 567         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 568         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 569
 570         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 571                 ArtifactDefinition.class, false);
 572         assertNull(afterConvert);
 573     }
 574
 575     @Test
 576     public void testMissingArtifactTypeValue() {
 577         ArtifactDefinition ad = new ArtifactDefinition();
 578
 579         JsonElement jsonArtifact = gson.toJsonTree(ad);
 580         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
 581         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 582         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 583         jsonArtifact.getAsJsonObject().add("artifactType", null);
 584         try {
 585             RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 586                     ArtifactDefinition.class, true);
 587             fail();
 588         } catch (ComponentException exp) {
 589             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MANDATORY_PROPERTY_MISSING_VALUE);
 590             assertThat(exp.getParams()[0]).isEqualTo("artifactType");
 591         }
 592     }
 593
 594     @Test
 595     public void testMissingArtifactLabel() {
 596         ArtifactDefinition ad = new ArtifactDefinition();
 597
 598         JsonElement jsonArtifact = gson.toJsonTree(ad);
 599         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
 600         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 601         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 602
 603         try {
 604             RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 605                     ArtifactDefinition.class, false);
 606             fail();
 607         } catch (ComponentException exp) {
 608             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
 609             assertThat(exp.getParams()[0]).isEqualTo("artifactLabel");
 610         }
 611     }
 612
 613     @Test
 614     public void testMissingArtifactTimeout() {
 615         ArtifactDefinition ad = new ArtifactDefinition();
 616
 617         JsonElement jsonArtifact = gson.toJsonTree(ad);
 618         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
 619         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 620         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 621
 622         try {
 623             RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 624                     ArtifactDefinition.class, true);
 625             fail();
 626         } catch (ComponentException exp) {
 627             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
 628             assertThat(exp.getParams()[0]).isEqualTo("timeout");
 629         }
 630     }
 631
 632
 633     @Test
 634     public void testInvalidGroupTypeWithSpace() {
 635         ArtifactDefinition ad = new ArtifactDefinition();
 636         ad.setArtifactName("artifact1");
 637         ad.setCreationDate(System.currentTimeMillis());
 638         ad.setMandatory(false);
 639         ad.setTimeout(15);
 640
 641         JsonElement jsonArtifact = gson.toJsonTree(ad);
 642         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 643         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 644         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 645         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 646
 647         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 648                 ArtifactDefinition.class, false);
 649         assertNull(afterConvert);
 650     }
 651
 652     @Test
 653     public void testInvalidTimeoutWithSpace() {
 654         ArtifactDefinition ad = new ArtifactDefinition();
 655         ad.setArtifactName("artifact1");
 656         ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 657         ad.setCreationDate(System.currentTimeMillis());
 658         ad.setMandatory(false);
 659
 660         JsonElement jsonArtifact = gson.toJsonTree(ad);
 661         jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
 662         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 663         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 664         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 665
 666         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 667                 ArtifactDefinition.class, true);
 668         assertNull(afterConvert);
 669     }
 670
 671     @Test
 672     public void testValidMibArtifactsConfiguration() {
 673         final ArtifactConfigManager artifactConfigManager = ArtifactConfigManager.getInstance();
 674         Optional<ArtifactConfiguration> artifactConfiguration = artifactConfigManager
 675             .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
 676         assertThat(artifactConfiguration.isPresent()).isTrue();
 677
 678         artifactConfiguration = artifactConfigManager
 679             .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
 680         assertThat(artifactConfiguration.isPresent()).isTrue();
 681
 682         artifactConfiguration = artifactConfigManager
 683             .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
 684         assertThat(artifactConfiguration.isPresent()).isTrue();
 685         artifactConfiguration = artifactConfigManager
 686             .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
 687         assertThat(artifactConfiguration.isPresent()).isTrue();
 688     }
 689
 690     @Test
 691     public void testDownloadServiceArtifactByNames() {
 692         Service service = new Service();
 693         String serviceName = "myService";
 694         String serviceVersion = "1.0";
 695         String serviceId = "serviceId";
 696         service.setName(serviceName);
 697         service.setVersion(serviceVersion);
 698         service.setUniqueId(serviceId);
 699
 700         String artifactName = "service-Myservice-template.yml";
 701         String artifactLabel = "assettoscatemplate";
 702         String esArtifactId = "123123dfgdfgd0";
 703         byte[] payload = "some payload".getBytes();
 704         ArtifactDefinition toscaTemplateArtifact = new ArtifactDefinition();
 705         toscaTemplateArtifact.setArtifactName(artifactName);
 706         toscaTemplateArtifact.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 707         toscaTemplateArtifact.setArtifactLabel(artifactLabel);
 708         toscaTemplateArtifact.setEsId(esArtifactId);
 709         toscaTemplateArtifact.setPayload(payload);
 710
 711         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 712         toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
 713         service.setToscaArtifacts(toscaArtifacts);
 714
 715         DAOArtifactData DAOArtifactData = new DAOArtifactData(esArtifactId);
 716         DAOArtifactData.setDataAsArray(payload);
 717         Either<DAOArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(DAOArtifactData);
 718         when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
 719         List<org.openecomp.sdc.be.model.Component> serviceList = new ArrayList<>();
 720         serviceList.add(service);
 721         Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> getServiceRes = Either
 722                 .left(serviceList);
 723         when(toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName)).thenReturn(getServiceRes);
 724         byte[] downloadServiceArtifactByNamesRes = artifactBL
 725                 .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
 726         assertThat(downloadServiceArtifactByNamesRes != null
 727                 && downloadServiceArtifactByNamesRes.length == payload.length).isTrue();
 728     }
 729
 730     @Test
 731     public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
 732         ArtifactDefinition heatArtifact = new ArtifactBuilder()
 733                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
 734                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
 735
 736         Resource component = new Resource();
 737         component.setComponentType(ComponentTypeEnum.RESOURCE);
 738                 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
 739         when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 740                 eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 741                 .thenReturn(Either.left(new ArtifactDefinition()));
 742         ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 743                 new ArrayList<>(), heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
 744                 Collections.emptyMap());
 745         assertNull(heatEnvPlaceHolder.getListHeatParameters());
 746     }
 747
 748     @Test
 749     public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
 750             throws Exception {
 751         HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
 752         HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
 753         HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
 754         ArtifactDefinition heatArtifact = new ArtifactBuilder().addHeatParam(heatParam1).addHeatParam(heatParam2)
 755                 .addHeatParam(heatParam3).build();
 756
 757         Resource component = new Resource();
 758
 759                 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
 760         when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 761                 eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 762                 .thenReturn(Either.left(new ArtifactDefinition()));
 763
 764         ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 765                 new ArrayList<>(), heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
 766                 Collections.emptyMap());
 767
 768         ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder;
 769         List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
 770         assertEquals(listHeatParameters.size(), 3);
 771         verifyHeatParam(listHeatParameters.get(0), heatParam1);
 772         verifyHeatParam(listHeatParameters.get(1), heatParam2);
 773         verifyHeatParam(listHeatParameters.get(2), heatParam3);
 774     }
 775
 776     @Test
 777     public void buildArtifactPayloadWhenShouldLockAndInTransaction() {
 778         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 779         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 780         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 781         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 782         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 783         artifactDefinition.setPayload(PAYLOAD);
 784         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 785
 786         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 787         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 788                 any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
 789         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 790         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 791         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 792                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
 793     }
 794
 795     @Test
 796     public void buildArtifactPayloadWhenShouldLockAndNotInTransaction() {
 797         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 798         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 799         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 800         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 801         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 802         artifactDefinition.setPayload(PAYLOAD);
 803         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 804
 805         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 806         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 807                 any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
 808         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 809         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 810         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 811                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 812         verify(janusGraphDao, times(1)).commit();
 813     }
 814
 815     private ArtifactDefinition buildArtifactPayload() {
 816         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 817         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 818         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 819         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 820         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 821         artifactDefinition.setPayload(PAYLOAD);
 822         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 823
 824         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 825         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 826                 any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
 827         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 828         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 829         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 830                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 831         verify(janusGraphDao, times(1)).commit();
 832         return artifactDefinition;
 833     }
 834
 835     private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
 836         assertEquals(heatEnvParam.getDefaultValue(), heatYamlParam.getCurrentValue());
 837         assertNull(heatEnvParam.getCurrentValue());
 838     }
 839
 840     //////////////////////////////////////////////////////////////////////////////////
 841     //////////////////////////////////new tests///////////////////////////////////////
 842     /////////////////////////////////////////////////////////////////////////////////
 843     private ArtifactsBusinessLogic createTestSubject() {
 844         return getTestSubject();
 845     }
 846
 847     @Test
 848     public void testBuildJsonStringForCsarVfcArtifact() throws Exception {
 849         ArtifactsBusinessLogic testSubject;
 850         ArtifactDefinition artifact = new ArtifactDefinition();
 851         String result;
 852
 853         // default test
 854         testSubject = createTestSubject();
 855         result = Deencapsulation.invoke(testSubject, "buildJsonStringForCsarVfcArtifact", new Object[]{artifact});
 856     }
 857
 858     @Test
 859     public void testCheckArtifactInComponent() throws Exception {
 860         ArtifactsBusinessLogic testSubject;
 861         Component component = new Resource();
 862         component.setComponentType(ComponentTypeEnum.RESOURCE);
 863         String artifactId = "";
 864         boolean result;
 865
 866         // default test
 867         testSubject = createTestSubject();
 868         result = Deencapsulation.invoke(testSubject, "checkArtifactInComponent",
 869                 new Object[]{component, artifactId});
 870     }
 871
 872
 873     @Test
 874     public void testCheckCreateFields() throws Exception {
 875         ArtifactsBusinessLogic testSubject;
 876         // User user = USER;
 877         ArtifactDefinition artifactInfo = buildArtifactPayload();
 878         ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
 879
 880         // default test
 881         testSubject = createTestSubject();
 882         Deencapsulation.invoke(testSubject, "checkCreateFields", user, artifactInfo, type);
 883     }
 884
 885     @Test
 886     public void testComposeArtifactId() throws Exception {
 887         ArtifactsBusinessLogic testSubject;
 888         String resourceId = "";
 889         String artifactId = "";
 890         ArtifactDefinition artifactInfo = buildArtifactPayload();
 891         String interfaceName = "";
 892         String operationName = "";
 893         String result;
 894
 895         // test 1
 896         testSubject = createTestSubject();
 897         result = Deencapsulation.invoke(testSubject, "composeArtifactId",
 898                 new Object[]{resourceId, artifactId, artifactInfo, interfaceName, operationName});
 899     }
 900
 901     @Test
 902     public void testConvertParentType() throws Exception {
 903         ArtifactsBusinessLogic testSubject;
 904         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 905         NodeTypeEnum result;
 906
 907         // default test
 908         testSubject = createTestSubject();
 909         result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[]{componentType});
 910     }
 911
 912     @Test
 913     public void testConvertToOperation() throws Exception {
 914         ArtifactsBusinessLogic testSubject;
 915         ArtifactDefinition artifactInfo = buildArtifactPayload();
 916         String operationName = "";
 917         Operation result;
 918
 919         // default test
 920         testSubject = createTestSubject();
 921         result = Deencapsulation.invoke(testSubject, "convertToOperation",
 922                 new Object[]{artifactInfo, operationName});
 923     }
 924
 925     @Test
 926     public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
 927         ArtifactsBusinessLogic testSubject;
 928         String operationName = "";
 929         String artifactName = "";
 930         String result;
 931
 932         // default test
 933         testSubject = createTestSubject();
 934         result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
 935                 new Object[]{operationName, artifactName});
 936     }
 937
 938     @Test
 939     public void testFetchArtifactsFromComponent() throws Exception {
 940         ArtifactsBusinessLogic testSubject;
 941         String artifactId = "";
 942         Component component = createResourceObject(true);
 943         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 944
 945         // default test
 946         testSubject = createTestSubject();
 947         Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
 948                 artifactId, component, artifacts);
 949     }
 950
 951
 952     @Test
 953     public void testValidateArtifact() throws Exception {
 954         ArtifactsBusinessLogic testSubject;
 955         String componentId = "";
 956         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 957         ArtifactsBusinessLogic arb = getTestSubject();
 958         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 959         String artifactId = "";
 960         ArtifactDefinition artifactInfo = buildArtifactPayload();
 961         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
 962
 963         Component component = createResourceObject(true);
 964         boolean shouldLock = false;
 965         boolean inTransaction = false;
 966
 967         // default test
 968         testSubject = createTestSubject();
 969         testSubject.validateArtifact(componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, shouldLock, inTransaction);
 970     }
 971
 972     @Test
 973     public void testHandleHeatEnvDownload() throws Exception {
 974         ArtifactsBusinessLogic testSubject;
 975         String componentId = "";
 976         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 977
 978         Component component = createResourceObject(true);
 979         ArtifactDefinition artifactInfo = buildArtifactPayload();
 980         boolean shouldLock = false;
 981         boolean inTransaction = false;
 982
 983
 984         // default test
 985         testSubject = createTestSubject();
 986         testSubject.handleHeatEnvDownload(componentId, componentType, user, component, artifactInfo, shouldLock, inTransaction);
 987     }
 988
 989     @Test
 990     public void testArtifactGenerationRequired() throws Exception {
 991         ArtifactsBusinessLogic testSubject;
 992         Component component = createResourceObject(true);
 993         ArtifactDefinition artifactInfo = buildArtifactPayload();
 994         boolean result;
 995
 996         // default test
 997         testSubject = createTestSubject();
 998         result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
 999                 new Object[]{component, artifactInfo});
1000     }
1001
1002     @Test
1003     public void testUpdateGroupForHeat() throws Exception {
1004         ArtifactsBusinessLogic testSubject;
1005         ArtifactDefinition artifactInfo = buildArtifactPayload();
1006         ArtifactDefinition artAfterUpdate = null;
1007         Component component = createResourceObject(true);
1008         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1009
1010         // default test
1011         testSubject = createTestSubject();
1012         testSubject.updateGroupForHeat(artifactInfo, artifactInfo, component);
1013     }
1014
1015     @Test
1016     public void testUpdateGroupForHeat_1() throws Exception {
1017         ArtifactsBusinessLogic testSubject;
1018         ArtifactDefinition artifactInfo = buildArtifactPayload();
1019         Component component = createResourceObject(true);
1020         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1021
1022         // default test
1023         testSubject = createTestSubject();
1024         testSubject.updateGroupForHeat(artifactInfo, artifactInfo, artifactInfo,
1025                 artifactInfo, component);
1026     }
1027
1028
1029     @Test
1030     public void testHandleAuditing() throws Exception {
1031         ArtifactsBusinessLogic testSubject;
1032         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1033         Component component = createResourceObject(true);
1034         String componentId = "";
1035
1036         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1037         String prevArtifactUuid = "";
1038         String currentArtifactUuid = "";
1039         ResponseFormat responseFormat = new ResponseFormat();
1040         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1041         String resourceInstanceName = "";
1042
1043         // test 1
1044         testSubject = createTestSubject();
1045         testSubject.setComponentsUtils(MockGenerator.mockComponentUtils());
1046         testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
1047                 prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
1048     }
1049
1050     @Test
1051     public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
1052         ArtifactsBusinessLogic testSubject;
1053         ArtifactsBusinessLogic arb = getTestSubject();
1054         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1055         ArtifactDefinition artifactInfo = buildArtifactPayload();
1056         ArtifactDefinition currentArtifactInfo = null;
1057
1058         // default test
1059         testSubject = createTestSubject();
1060         Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
1061                 operation, artifactInfo, artifactInfo);
1062     }
1063
1064     @Test
1065     public void testFindArtifactOnParentComponent() {
1066         ArtifactsBusinessLogic testSubject;
1067         Component component = createResourceObject(true);
1068         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1069         String parentId = "";
1070         ArtifactsBusinessLogic arb = getTestSubject();
1071         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1072         String artifactId = "";
1073         Either<ArtifactDefinition, ResponseFormat> result;
1074
1075         // default test
1076         testSubject = createTestSubject();
1077         result = Deencapsulation.invoke(testSubject, "findArtifact", new Object[]{component,
1078                 componentType, parentId, operation, artifactId});
1079     }
1080
1081
1082     @Test
1083     public void testValidateInformationalArtifact() throws Exception {
1084         ArtifactsBusinessLogic testSubject;
1085         ArtifactDefinition artifactInfo = buildArtifactPayload();
1086         Component component = createResourceObject(true);
1087         Either<Boolean, ResponseFormat> result;
1088
1089         // default test
1090         testSubject = createTestSubject();
1091         result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
1092                 new Object[]{artifactInfo, component});
1093     }
1094
1095
1096     @Test
1097     public void testGetUpdatedGroups() throws Exception {
1098         ArtifactsBusinessLogic testSubject;
1099         String artifactId = "";
1100         ArtifactDefinition artifactInfo = buildArtifactPayload();
1101         List<GroupDefinition> groups = new ArrayList<>();
1102         List<GroupDataDefinition> result;
1103
1104         // test 1
1105         testSubject = createTestSubject();
1106         result = Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
1107     }
1108
1109
1110     @Test
1111     public void testGetUpdatedGroupInstances() throws Exception {
1112         ArtifactsBusinessLogic testSubject;
1113         String artifactId = "";
1114         ArtifactDefinition artifactInfo = buildArtifactPayload();
1115         List<GroupDefinition> groups = new ArrayList<>();
1116         List<GroupInstance> result;
1117
1118         // default test
1119         testSubject = createTestSubject();
1120         result = Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
1121     }
1122
1123
1124     @Test
1125     public void testFindArtifact_1() throws Exception {
1126         ArtifactsBusinessLogic testSubject;
1127         String artifactId = "";
1128         Component component = createResourceObject(true);
1129         String parentId = "";
1130         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1131         Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> result;
1132
1133         // default test
1134         testSubject = createTestSubject();
1135         result = Deencapsulation.invoke(testSubject, "findArtifact",
1136                 new Object[]{artifactId, component, parentId, componentType});
1137     }
1138
1139
1140     @Test
1141     public void testFetchArtifactsFromInstance() throws Exception {
1142         ArtifactsBusinessLogic testSubject;
1143         String artifactId = "";
1144         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1145         ComponentInstance instance = new ComponentInstance();
1146
1147
1148         // default test
1149         testSubject = createTestSubject();
1150         Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
1151     }
1152
1153
1154     @Test
1155     public void testGenerateCustomizationUUIDOnInstance() throws Exception {
1156         ArtifactsBusinessLogic testSubject;
1157         String componentId = "";
1158         String instanceId = "";
1159         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1160         StorageOperationStatus result;
1161
1162         // default test
1163         testSubject = createTestSubject();
1164         result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
1165                 new Object[]{componentId, instanceId, componentType});
1166     }
1167
1168     @Test
1169     public void testFindComponentInstance() {
1170         ArtifactsBusinessLogic testSubject;
1171         String componentInstanceId = "";
1172         Component component = createResourceObject(true);
1173         ComponentInstance result;
1174
1175         // default test
1176         testSubject = createTestSubject();
1177         result = Deencapsulation.invoke(testSubject, "findComponentInstance",
1178                 new Object[]{componentInstanceId, component});
1179     }
1180
1181     @Test(expected = ComponentException.class)
1182     public void testDeploymentArtifactTypeIsLegalForParent_shouldThrowException() {
1183         ArtifactsBusinessLogic testSubject;
1184         ArtifactDefinition artifactInfo = buildArtifactPayload();
1185         ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
1186         Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts = new HashMap<>();
1187         // test 1
1188         testSubject = createTestSubject();
1189         testSubject.validateDeploymentArtifactTypeIsLegalForParent(artifactInfo, artifactType, resourceDeploymentArtifacts);
1190     }
1191
1192     @Test
1193     public void testLoadArtifactTypeConfig() {
1194         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1195         //null artifactType
1196         Optional<ArtifactConfiguration> artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(null);
1197         assertThat(artifactConfiguration.isPresent()).isFalse();
1198         //not configured artifactType
1199         artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig("NotConfiguredArtifactType");
1200         assertThat(artifactConfiguration.isPresent()).isFalse();
1201
1202         //valid artifactType
1203         final String artifactType = ArtifactTypeEnum.YANG.getType();
1204         artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(artifactType);
1205         assertThat(artifactConfiguration.isPresent()).isTrue();
1206         final ArtifactConfiguration artifactConfiguration1 = artifactConfiguration.get();
1207         assertThat(artifactConfiguration1.getType()).isEqualTo(artifactType);
1208         assertThat(artifactConfiguration1.getCategories()).hasSize(1);
1209         assertThat(artifactConfiguration1.getCategories()).contains(ArtifactGroupTypeEnum.INFORMATIONAL);
1210         assertThat(artifactConfiguration1.getComponentTypes()).hasSize(1);
1211         assertThat(artifactConfiguration1.getComponentTypes()).contains(ComponentType.RESOURCE);
1212         assertThat(artifactConfiguration1.getResourceTypes()).hasSize(7);
1213         assertThat(artifactConfiguration1.getResourceTypes())
1214             .contains(ResourceTypeEnum.VFC.getValue(), ResourceTypeEnum.CP.getValue(), ResourceTypeEnum.VL.getValue(),
1215                 ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.VFCMT.getValue(), "Abstract",
1216                 ResourceTypeEnum.CVFC.getValue());
1217     }
1218
1219     @Test
1220     public void testValidateArtifactExtension_acceptedExtension() {
1221         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1222         artifactInfo.setArtifactName("artifact.yml");
1223         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1224         //empty accepted types
1225         assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(new ArtifactConfiguration(), artifactInfo))
1226             .doesNotThrowAnyException();
1227
1228         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1229         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1230         assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo))
1231             .doesNotThrowAnyException();
1232     }
1233
1234     @Test(expected = ComponentException.class)
1235     public void testValidateArtifactExtension_notAcceptedExtension() {
1236         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1237         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1238         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1239         //not accepted extension
1240         artifactInfo.setArtifactName("artifact.xml");
1241
1242         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1243
1244         artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1245     }
1246
1247     @Test(expected = ComponentException.class)
1248     public void testValidateArtifactExtension_noExtension() {
1249         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1250         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1251         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1252         //no extension in the artifact name
1253         artifactInfo.setArtifactName("artifact");
1254
1255         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1256
1257         artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1258     }
1259
1260     @Test(expected = ComponentException.class)
1261     public void testValidateHeatEnvDeploymentArtifact_shouldThrowException() {
1262         ArtifactsBusinessLogic testSubject;
1263         Component component = createResourceObject(true);
1264         String parentId = "";
1265         ArtifactDefinition artifactInfo = buildArtifactPayload();
1266         // default test
1267         testSubject = createTestSubject();
1268         testSubject.validateHeatEnvDeploymentArtifact(component, parentId, artifactInfo);
1269     }
1270
1271     @Test
1272     public void testFillArtifactPayloadValidation() throws Exception {
1273         ArtifactsBusinessLogic testSubject;
1274         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1275         Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1276         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1277
1278         // default test
1279         testSubject = createTestSubject();
1280         testSubject.fillArtifactPayload(payloadWrapper, artifactDefinition);
1281     }
1282
1283
1284
1285     @Test
1286     public void testIsValidXml() throws Exception {
1287         ArtifactsBusinessLogic testSubject;
1288         byte[] xmlToParse = new byte[]{' '};
1289         boolean result;
1290
1291         // default test
1292         testSubject = createTestSubject();
1293         result = Deencapsulation.invoke(testSubject, "isValidXml", new Object[]{xmlToParse});
1294     }
1295
1296     @Test(expected = ByActionStatusComponentException.class)
1297     public void testHeatTimeoutValue() {
1298         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1299         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1300         artifactInfo.setTimeout(1);
1301         artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1302         artifactInfo.setTimeout(0);
1303         artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1304     }
1305
1306     @Test
1307     public void testValidateResourceType_resourceTypeIsAccepted() {
1308         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1309         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1310         final List<String> typeList = Arrays
1311             .asList(ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.PNF.getValue(), ResourceTypeEnum.VFC.getValue());
1312         assertThatCode(() -> {
1313             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1314         }).doesNotThrowAnyException();
1315     }
1316
1317     @Test(expected=ComponentException.class)
1318     public void testValidateResourceType_invalidResourceType() {
1319         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1320         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1321         final List<String> typeList = Collections.singletonList(ResourceTypeEnum.PNF.getValue());
1322         artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1323     }
1324
1325     @Test
1326     public void testValidateResourceType_emptyResourceTypeConfig_resourceTypeIsAccepted() {
1327         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1328         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1329         assertThatCode(() -> {
1330             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, null);
1331         }).doesNotThrowAnyException();
1332         assertThatCode(() -> {
1333             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, new ArrayList<>());
1334         }).doesNotThrowAnyException();
1335     }
1336
1337     @Test
1338     public void testValidateAndConvertHeatParameters() throws Exception {
1339         ArtifactsBusinessLogic testSubject;
1340         ArtifactDefinition artifactInfo = buildArtifactPayload();
1341         String artifactType = "";
1342         Either<ArtifactDefinition, ResponseFormat> result;
1343
1344         // default test
1345         testSubject = createTestSubject();
1346         testSubject.validateAndConvertHeatParameters(artifactInfo, artifactType);
1347     }
1348
1349     @Test
1350     public void testGetDeploymentArtifacts() throws Exception {
1351         ArtifactsBusinessLogic testSubject;
1352         Component component = createResourceObject(true);
1353         NodeTypeEnum parentType = null;
1354         String ciId = "";
1355         List<ArtifactDefinition> result;
1356
1357         // default test
1358         testSubject = createTestSubject();
1359         result = testSubject.getDeploymentArtifacts(component, ciId);
1360     }
1361
1362
1363     @Test
1364     public void testValidateFirstUpdateHasPayload() throws Exception {
1365         ArtifactsBusinessLogic testSubject;
1366         ArtifactDefinition artifactInfo = buildArtifactPayload();
1367         ArtifactDefinition currentArtifact = null;
1368         Either<Boolean, ResponseFormat> result;
1369
1370         // default test
1371         testSubject = createTestSubject();
1372         result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1373                 new Object[]{artifactInfo, artifactInfo});
1374     }
1375
1376     @Test
1377     public void testValidateAndSetArtifactname() throws Exception {
1378         ArtifactsBusinessLogic testSubject;
1379         ArtifactDefinition artifactInfo = buildArtifactPayload();
1380         Either<Boolean, ResponseFormat> result;
1381
1382         // default test
1383         testSubject = createTestSubject();
1384         testSubject.validateAndSetArtifactName(artifactInfo);
1385     }
1386
1387     @Test(expected = ComponentException.class)
1388     public void testValidateArtifactType_notConfiguredArtifactType() {
1389         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1390         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1391         artifactInfo.setArtifactType("notConfiguredType");
1392         Deencapsulation
1393             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1394     }
1395
1396     @Test(expected = ComponentException.class)
1397     public void testValidateArtifactType_componentTypeNotSupportedByArtifactType() {
1398         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1399         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1400         artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1401
1402         Deencapsulation
1403             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1404     }
1405
1406     @Test(expected = ComponentException.class)
1407     public void testValidateArtifactType_groupTypeNotSupportedByArtifactType() {
1408         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1409         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1410         artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1411         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1412
1413         Deencapsulation
1414             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.SERVICE);
1415     }
1416
1417     @Test
1418     public void testValidateArtifactTypeNotChanged() throws Exception {
1419         ArtifactsBusinessLogic testSubject;
1420         ArtifactDefinition artifactInfo = buildArtifactPayload();
1421         ArtifactDefinition currentArtifact = null;
1422         Either<Boolean, ResponseFormat> result;
1423
1424         // default test
1425         testSubject = createTestSubject();
1426         result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1427                 new Object[]{artifactInfo, artifactInfo});
1428     }
1429
1430
1431     @Test
1432     public void testValidateOrSetArtifactGroupType() throws Exception {
1433         ArtifactsBusinessLogic testSubject;
1434         ArtifactDefinition artifactInfo = buildArtifactPayload();
1435         ArtifactDefinition currentArtifact = null;
1436         Either<ArtifactDefinition, ResponseFormat> result;
1437
1438         // default test
1439         testSubject = createTestSubject();
1440         result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1441                 new Object[]{artifactInfo, artifactInfo});
1442     }
1443
1444     @Test
1445     public void testCheckAndSetUnUpdatableFields() throws Exception {
1446         ArtifactsBusinessLogic testSubject;
1447
1448         ArtifactDefinition artifactInfo = buildArtifactPayload();
1449         ArtifactDefinition currentArtifact = null;
1450         ArtifactGroupTypeEnum type = null;
1451
1452         // test 1
1453         testSubject = createTestSubject();
1454         type = null;
1455         Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", user,
1456                 artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class);
1457     }
1458
1459     @Test
1460     public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1461         ArtifactsBusinessLogic testSubject;
1462         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1463         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1464
1465
1466         // default test
1467         testSubject = createTestSubject();
1468         Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1469     }
1470
1471     @Test
1472     public void testGetMapOfParameters() throws Exception {
1473         ArtifactsBusinessLogic testSubject;
1474         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1475         Map<String, HeatParameterDefinition> result;
1476
1477         // default test
1478         testSubject = createTestSubject();
1479         result = Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1480     }
1481
1482     @Test
1483     public void testGivenValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1484         final byte[] payload = "validYaml: yes".getBytes();
1485         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1486
1487         final boolean isArtifactMetadataUpdate = false;
1488         ArtifactsBusinessLogic testSubject = getTestSubject();
1489
1490         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1491                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1492         assertArrayEquals(payload, result.left().value());
1493     }
1494
1495
1496
1497
1498
1499     @Test
1500         public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1501                 final int expectedStatus = 100;
1502                 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1503                 final byte[] payload = "invalidYaml".getBytes();
1504                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1505
1506         final boolean isArtifactMetadataUpdate = false;
1507         ArtifactsBusinessLogic testSubject = getTestSubject();
1508         testSubject.setComponentsUtils(componentsUtils);
1509
1510         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1511                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1512
1513         int status = result.right().value().getStatus();
1514         assertEquals(expectedStatus, status);
1515     }
1516
1517     @Test
1518         public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
1519                 final int expectedStatus = 101;
1520                 when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1521                 final byte[] payload = "".getBytes();
1522                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1523
1524         final boolean isArtifactMetadataUpdate = false;
1525         ArtifactsBusinessLogic testSubject = getTestSubject();
1526         testSubject.setComponentsUtils(componentsUtils);
1527
1528         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1529                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1530
1531                 int status = result.right().value().getStatus();
1532                 assertEquals(expectedStatus, status);
1533     }
1534
1535
1536     @Test
1537         public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1538                 final byte[] payload = "heat_template_version: 1.0".getBytes();
1539                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1540
1541         final boolean isArtifactMetadataUpdate = false;
1542         ArtifactsBusinessLogic testSubject = getTestSubject();
1543
1544         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1545                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1546         assertArrayEquals(payload, result.left().value());
1547     }
1548
1549     @Test
1550         public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1551                 final int expectedStatus = 1000;
1552                 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1553                 final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
1554                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1555
1556         final boolean isArtifactMetadataUpdate = false;
1557         ArtifactsBusinessLogic testSubject = getTestSubject();
1558         testSubject.setComponentsUtils(componentsUtils);
1559
1560         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1561                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1562
1563         int status = result.right().value().getStatus();
1564         assertEquals(expectedStatus, status);
1565     }
1566
1567     private ArtifactDefinition createArtifactInfo(byte[] payload, String artifactName, ArtifactTypeEnum artifactType) {
1568         ArtifactDefinition artifactInfo = new ArtifactDefinition();
1569         artifactInfo.setArtifactName(artifactName);
1570         artifactInfo.setArtifactType(artifactType.getType());
1571         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1572         artifactInfo.setPayload(Base64.encodeBase64(payload));
1573         return artifactInfo;
1574     }
1575
1576     @Test
1577     public void testValidateUserRole() throws Exception {
1578         ArtifactsBusinessLogic testSubject;
1579
1580         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
1581         String componentId = "";
1582         String artifactId = "";
1583         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1584         ArtifactsBusinessLogic arb = getTestSubject();
1585         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1586         Either<Boolean, ResponseFormat> result;
1587
1588         // default test
1589         testSubject = createTestSubject();
1590         result = Deencapsulation.invoke(testSubject, "validateUserRole",
1591                 new Object[]{user, auditingAction, componentId, artifactId, componentType,
1592                         operation});
1593         assertNull(result);
1594     }
1595
1596     @Test
1597     public void testDetectAuditingType() throws Exception {
1598         ArtifactsBusinessLogic testSubject;
1599         ArtifactsBusinessLogic arb = getTestSubject();
1600         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1601         String origMd5 = "";
1602         AuditingActionEnum result;
1603
1604         // default test
1605         testSubject = createTestSubject();
1606         result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1607                 new Object[]{operation, origMd5});
1608         assertNotNull(result);
1609     }
1610
1611     @Test
1612     public void testDetectNoAuditingType() throws Exception {
1613         ArtifactsBusinessLogic testSubject;
1614         ArtifactsBusinessLogic arb = getTestSubject();
1615         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.LINK);
1616         String origMd5 = "";
1617         AuditingActionEnum result;
1618
1619         // default test
1620         testSubject = createTestSubject();
1621         result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1622                 new Object[]{operation, origMd5});
1623         assertNull(result);
1624     }
1625
1626     @Test
1627     public void testCreateEsArtifactData() throws Exception {
1628         ArtifactsBusinessLogic testSubject;
1629         ArtifactDataDefinition artifactInfo = buildArtifactPayload();
1630         byte[] artifactPayload = new byte[]{' '};
1631         DAOArtifactData result;
1632
1633         // default test
1634         testSubject = createTestSubject();
1635         result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1636         assertNotNull(result);
1637     }
1638
1639
1640     @Test
1641     public void testIsArtifactMetadataUpdateTrue() throws Exception {
1642         ArtifactsBusinessLogic testSubject;
1643         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ARTIFACT_METADATA_UPDATE;
1644         boolean result;
1645
1646         // default test
1647         testSubject = createTestSubject();
1648         result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1649                 new Object[]{auditingActionEnum});
1650         assertThat(result).isTrue();
1651     }
1652
1653     @Test
1654     public void testIsArtifactMetadataUpdateFalse() throws Exception {
1655         ArtifactsBusinessLogic testSubject;
1656         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1657         boolean result;
1658
1659         // default test
1660         testSubject = createTestSubject();
1661         result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1662                 new Object[]{auditingActionEnum});
1663         assertThat(result).isFalse();
1664     }
1665
1666     @Test
1667     public void testIsDeploymentArtifactTrue() throws Exception {
1668         ArtifactsBusinessLogic testSubject;
1669         ArtifactDefinition artifactInfo = buildArtifactPayload();
1670         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1671         boolean result;
1672
1673         // default test
1674         testSubject = createTestSubject();
1675         result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1676         assertThat(result).isTrue();
1677     }
1678
1679     @Test
1680     public void testIsDeploymentArtifactFalse() throws Exception {
1681         ArtifactsBusinessLogic testSubject;
1682         ArtifactDefinition artifactInfo = buildArtifactPayload(); // artifactGroupType == ArtifactGroupTypeEnum.TOSCA
1683         boolean result;
1684
1685         // default test
1686         testSubject = createTestSubject();
1687         result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1688         assertThat(result).isFalse();
1689     }
1690
1691     @Test
1692     public void testSetArtifactPlaceholderCommonFields() throws Exception {
1693         ArtifactsBusinessLogic testSubject;
1694         String resourceId = ES_ARTIFACT_ID;
1695
1696         ArtifactDefinition artifactInfo = buildArtifactPayload();
1697
1698         // test 1
1699         testSubject = createTestSubject();
1700         Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1701                 resourceId, user, artifactInfo);
1702         assertEquals(resourceId + "." +ARTIFACT_LABEL, artifactInfo.getUniqueId());
1703         assertEquals(user.getFullName(), artifactInfo.getCreatorFullName());
1704     }
1705
1706
1707     @Test
1708     public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1709         ArtifactsBusinessLogic testSubject;
1710         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1711         String payloadStr = "";
1712         Either<DAOArtifactData, ResponseFormat> result;
1713
1714         // default test
1715         testSubject = createTestSubject();
1716         result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1717                 new Object[]{artifactDefinition, payloadStr});
1718         assertThat(result.isLeft()).isTrue();
1719     }
1720
1721     @Test
1722     public void testUpdateArtifactOnGroupInstance() throws Exception {
1723         ArtifactsBusinessLogic testSubject;
1724         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1725         Component component = createResourceObject(true);
1726         String instanceId = "";
1727         String prevUUID = "";
1728         ArtifactDefinition artifactInfo = buildArtifactPayload();
1729         Either<ArtifactDefinition, ResponseFormat> result;
1730
1731         // test 1
1732         testSubject = createTestSubject();
1733         result = testSubject.updateArtifactOnGroupInstance(component, instanceId, prevUUID, artifactInfo, artifactInfo);
1734         assertThat(result.isLeft()).isTrue();
1735     }
1736
1737     @Test
1738     public void testGenerateHeatEnvPayload() throws Exception {
1739         ArtifactsBusinessLogic testSubject;
1740         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1741         String result;
1742
1743         // default test
1744         testSubject = createTestSubject();
1745         result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1746                 new Object[]{artifactDefinition});
1747         assertThat(result.isEmpty()).isFalse();
1748     }
1749
1750
1751     @Test
1752     public void testBuildJsonForUpdateArtifact() throws Exception {
1753         ArtifactsBusinessLogic testSubject;
1754         ArtifactDefinition artifactInfo = buildArtifactPayload();
1755         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1756         List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1757         Map<String, Object> result;
1758
1759         // default test
1760         testSubject = createTestSubject();
1761         result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1762         assertThat(MapUtils.isNotEmpty(result)).isTrue();
1763     }
1764
1765     @Test
1766     public void testBuildJsonForUpdateArtifact_1() throws Exception {
1767         ArtifactsBusinessLogic testSubject;
1768         String artifactId = "";
1769         String artifactName = "";
1770         String artifactType = "";
1771         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1772         String label = "";
1773         String displayName = "";
1774         String description = "";
1775         byte[] artifactContent = new byte[]{' '};
1776         List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1777         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1778         Map<String, Object> result;
1779
1780         // test 1
1781         testSubject = createTestSubject();
1782         artifactId = "";
1783         result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1784                 label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1785         assertThat(MapUtils.isNotEmpty(result)).isTrue();
1786     }
1787
1788
1789     @Test
1790     public void testNotReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1791         ArtifactsBusinessLogic testSubject;
1792         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1793         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1794
1795
1796         // default test
1797         testSubject = createTestSubject();
1798         boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1799         assertThat(result).isFalse();
1800     }
1801
1802
1803     @Test
1804     public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1805         ArtifactsBusinessLogic testSubject;
1806         HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1807         hpdOrig.setName("param1");
1808         hpdOrig.setCurrentValue("value1");
1809
1810         HeatParameterDefinition hpdUpd = new HeatParameterDefinition();
1811         hpdUpd.setName("param1");
1812         hpdUpd.setCurrentValue("value2");
1813
1814         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1815         currentHeatEnvParams.add(hpdOrig);
1816
1817         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1818         updatedHeatEnvParams.add(hpdUpd);
1819
1820         // default test
1821         testSubject = createTestSubject();
1822         boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1823         assertThat(result).isTrue();
1824         assertEquals(hpdUpd.getCurrentValue(), hpdOrig.getCurrentValue());
1825     }
1826
1827
1828     @Test
1829     public void testExtractArtifactDefinition() throws Exception {
1830         ArtifactsBusinessLogic testSubject;
1831         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1832         Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1833         ArtifactDefinition result;
1834
1835         // default test
1836         testSubject = createTestSubject();
1837         result = testSubject.extractArtifactDefinition(eitherArtifact);
1838         assertNotNull(result);
1839         assertEquals(artifactDefinition, result);
1840     }
1841
1842
1843     @Test
1844     public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1845         ArtifactsBusinessLogic testSubject;
1846         ArtifactDefinition artifact = buildArtifactPayload();
1847         ArtifactDefinition artifactInfo = new ArtifactDefinition();
1848
1849         HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1850         hpdOrig.setName("param1");
1851         hpdOrig.setCurrentValue("value1");
1852         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1853         currentHeatEnvParams.add(hpdOrig);
1854         artifact.setListHeatParameters(currentHeatEnvParams);
1855
1856         // default test
1857         testSubject = createTestSubject();
1858         Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1859                 artifact, artifactInfo);
1860
1861         assertNotEquals(artifact, artifactInfo);
1862         assertEquals(1, artifact.getListHeatParameters().size());
1863         assertEquals(1, artifactInfo.getListHeatParameters().size());
1864
1865         String hpdOrigCurrValue = artifact.getListHeatParameters().get(0).getCurrentValue();
1866         String hpdNewDefaultValue = artifactInfo.getListHeatParameters().get(0).getDefaultValue();
1867
1868         assertEquals(hpdOrigCurrValue, hpdNewDefaultValue);
1869     }
1870
1871     @Test
1872     public void testBuildHeatEnvFileNameArtifactNameNotNull() throws Exception {
1873         String heatEnvExt = "zip";
1874         ArtifactsBusinessLogic testSubject;
1875         ArtifactDefinition heatArtifact = buildArtifactPayload();
1876         ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1877         Map<String, Object> placeHolderData = new HashMap<>();
1878         placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1879         String artName = ARTIFACT_NAME.split("\\.")[0];
1880
1881         // default test
1882         testSubject = createTestSubject();
1883         Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1884         assertThat(heatEnvArtifact.getArtifactName().startsWith(artName)).isTrue();
1885         assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1886     }
1887
1888     @Test
1889     public void testBuildHeatEnvFileNameArtifactNameIsNull() throws Exception {
1890         String heatEnvExt = "zip";
1891         ArtifactsBusinessLogic testSubject;
1892         ArtifactDefinition heatArtifact = buildArtifactPayload();
1893         heatArtifact.setArtifactName(null);
1894         ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1895         Map<String, Object> placeHolderData = new HashMap<>();
1896         placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1897
1898         // default test
1899         testSubject = createTestSubject();
1900         Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1901         assertThat(heatEnvArtifact.getArtifactName().startsWith(ARTIFACT_LABEL)).isTrue();
1902         assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1903     }
1904
1905     @Test
1906     public void testHandleEnvArtifactVersion() throws Exception {
1907         ArtifactsBusinessLogic testSubject;
1908         String existingVersion = "1.0";
1909         ArtifactDefinition artifactInfo = buildArtifactPayload();
1910         Map<String, String> existingEnvVersions = new HashMap<>();
1911         existingEnvVersions.put(artifactInfo.getArtifactName(), existingVersion);
1912
1913         // test 1
1914         testSubject = createTestSubject();
1915         Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", artifactInfo, existingEnvVersions);
1916         assertEquals(existingVersion, artifactInfo.getArtifactVersion());
1917     }
1918
1919     @Test
1920     public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1921         ArtifactsBusinessLogic testSubject;
1922         List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();
1923         Resource component = createResourceObject(true);
1924
1925         List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();
1926         ArtifactsBusinessLogic arb = getTestSubject();
1927         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1928         boolean shouldLock = false;
1929         boolean inTransaction = false;
1930         List<ArtifactDefinition> result;
1931
1932         // default test
1933         testSubject = createTestSubject();
1934         result = testSubject.handleArtifactsForInnerVfcComponent(artifactsToHandle, component, user,
1935                 vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1936
1937         assertThat(CollectionUtils.isEmpty(result)).isTrue();
1938     }
1939
1940     @Test
1941     public void testSetNodeTemplateOperation() throws Exception {
1942         ArtifactsBusinessLogic testSubject;
1943         NodeTemplateOperation nodeTemplateOperation = new NodeTemplateOperation();
1944
1945         // default test
1946         testSubject = createTestSubject();
1947         Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", nodeTemplateOperation);
1948         assertEquals(Deencapsulation.getField(testSubject, "nodeTemplateOperation"), nodeTemplateOperation);
1949     }
1950
1951
1952     @Test(expected = ComponentException.class)
1953     public void validateDeploymentArtifact_invalidComponentType() {
1954         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1955         Component component = new Resource();
1956         component.setComponentType(ComponentTypeEnum.PRODUCT);
1957         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1958         Deencapsulation
1959             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1960     }
1961
1962     @Test(expected = ComponentException.class)
1963     public void validateDeploymentArtifact_notConfiguredArtifactType() {
1964         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1965         Component component = new Resource();
1966         component.setComponentType(ComponentTypeEnum.RESOURCE);
1967         artifactDefinition.setArtifactType("NotConfiguredType");
1968         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1969         Deencapsulation
1970             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1971     }
1972
1973     @Test(expected = ComponentException.class)
1974     public void validateDeploymentArtifact_unsupportedResourceType() {
1975         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1976         artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
1977         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1978         final Resource resourceComponent = new Resource();
1979         resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1980         resourceComponent.setResourceType(ResourceTypeEnum.ServiceProxy);
1981         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1982         Deencapsulation
1983             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1984     }
1985
1986     @Test
1987     public void validateDeploymentArtifact_validArtifact() {
1988         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1989         artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
1990         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1991         final Resource resourceComponent = new Resource();
1992         resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1993         resourceComponent.setResourceType(ResourceTypeEnum.VF);
1994         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1995         assertThatCode(() -> {
1996             Deencapsulation
1997                 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1998         }).doesNotThrowAnyException();
1999
2000     }
2001
2002     @Test
2003     public void validateHeatArtifact_validArtifact() {
2004         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2005         artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
2006         artifactDefinition.setTimeout(1);
2007         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2008         assertThatCode(() -> {
2009             Deencapsulation
2010                 .invoke(artifactsBusinessLogic, "validateHeatArtifact", new Resource(), "componentId", artifactDefinition);
2011         }).doesNotThrowAnyException();
2012     }
2013
2014     @Test
2015     public void validateInputForResourceInstance() {
2016         final String artifactId = "artifactId";
2017         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2018         artifactDefinition.setUniqueId(artifactId);
2019         artifactDefinition.setArtifactName(ARTIFACT_NAME);
2020         artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
2021         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
2022         artifactDefinition.setEsId(ES_ARTIFACT_ID);
2023         artifactDefinition.setPayload(PAYLOAD);
2024         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
2025         artifactDefinition.setDescription("artifact description");
2026         artifactDefinition.setServiceApi(true);
2027         artifactDefinition.setApiUrl("dumbUrl");
2028
2029         final User user = new User();
2030         user.setUserId("userId");
2031         user.setRole(Role.ADMIN.name());
2032
2033         final String parentId = "parentId";
2034         final Service service = new Service();
2035         service.setComponentType(ComponentTypeEnum.SERVICE);
2036         service.setUniqueId(parentId);
2037         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2038         service.setLastUpdaterUserId(user.getUserId());
2039
2040         final ArtifactOperationInfo operationInfo =
2041             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2042
2043         final String componentId = "componentId";
2044         final ComponentInstance componentInstance = new ComponentInstance();
2045         componentInstance.setUniqueId(componentId);
2046         componentInstance.setComponentUid(componentId);
2047         service.setComponentInstances(Collections.singletonList(componentInstance));
2048
2049         final Resource resource = new Resource();
2050         when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2051         when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2052
2053         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2054         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2055         Object result = Deencapsulation
2056             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2057                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2058         assertTrue(result instanceof Either<?, ?>);
2059         assertTrue(((Either<?, ?>) result).isLeft());
2060
2061         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2062
2063         result = Deencapsulation
2064             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2065                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2066         assertTrue(result instanceof Either<?, ?>);
2067         assertTrue(((Either<?, ?>) result).isLeft());
2068     }
2069
2070     @Test
2071     public void validateInputForResourceInstanceDeploymentArtifact() {
2072         final String artifactId = "artifactId";
2073         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2074         artifactDefinition.setUniqueId(artifactId);
2075         artifactDefinition.setArtifactName(ARTIFACT_NAME);
2076         artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
2077         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
2078         artifactDefinition.setEsId(ES_ARTIFACT_ID);
2079         artifactDefinition.setPayload(PAYLOAD);
2080         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2081         artifactDefinition.setDescription("artifact description");
2082
2083         final User user = new User();
2084         user.setUserId("userId");
2085         user.setRole(Role.ADMIN.name());
2086
2087         final String parentId = "parentId";
2088         final Service service = new Service();
2089         service.setComponentType(ComponentTypeEnum.SERVICE);
2090         service.setUniqueId(parentId);
2091         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2092         service.setLastUpdaterUserId(user.getUserId());
2093
2094         final ArtifactOperationInfo operationInfo =
2095             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2096
2097         final String componentId = "componentId";
2098         final ComponentInstance componentInstance = new ComponentInstance();
2099         componentInstance.setUniqueId(componentId);
2100         componentInstance.setComponentUid(componentId);
2101         service.setComponentInstances(Collections.singletonList(componentInstance));
2102
2103         final Resource resource = new Resource();
2104         when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2105         when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2106
2107         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2108         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2109
2110         final Object result = Deencapsulation
2111             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2112                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2113         assertTrue(result instanceof Either<?, ?>);
2114         assertTrue(((Either<?, ?>) result).isLeft());
2115     }
2116
2117
2118     @Test
2119     public void testHandleArtifactRequest() {
2120
2121         String componentId = "componentId";
2122         ArtifactOperationInfo operationInfo = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE);
2123         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2124         artifactDefinition.setArtifactName("other");
2125         artifactDefinition.setUniqueId("artifactId");
2126         artifactDefinition.setPayload("Test".getBytes());
2127         artifactDefinition.setArtifactLabel("other");
2128         artifactDefinition.setDescription("Test artifact");
2129         artifactDefinition.setArtifactType(ArtifactTypeEnum.OTHER.getType());
2130         artifactDefinition.setArtifactUUID("artifactUId");
2131         artifactDefinition.setArtifactLabel("test");
2132         artifactDefinition.setArtifactDisplayName("Test");
2133         artifactDefinition.setEsId("esId");
2134
2135         String requestMd5 = GeneralUtility.calculateMD5Base64EncodedByString("data");
2136         User user = new User();
2137         user.setUserId("userId");
2138
2139         List<ComponentInstance> componentInstanceList = new ArrayList<>();
2140         List<InterfaceDefinition> interfaceDefinitionsList = new ArrayList<>();
2141         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2142         Map<String, Operation> operationsMap = new HashMap<>();
2143         artifactDefinitionMap.put("sample", artifactDefinition);
2144
2145         ComponentInstance componentInstance = new ComponentInstance();
2146         componentInstance.setUniqueId(componentId);
2147         componentInstance.setDeploymentArtifacts(artifactDefinitionMap);
2148         componentInstanceList.add(componentInstance);
2149
2150         Operation operation = new Operation();
2151         operation.setUniqueId("ouuid");
2152         operation.setName("operation1");
2153         operation.setImplementation(artifactDefinition);
2154         operationsMap.put("op1", operation);
2155
2156         Map<String, InterfaceDefinition> interfaceDefinitions = new HashMap<>();
2157
2158         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2159         interfaceDefinition.setType("iuuid");
2160         interfaceDefinition.setOperationsMap(operationsMap);
2161         interfaceDefinitions.put("iuuid", interfaceDefinition);
2162
2163         interfaceDefinitionsList.add(interfaceDefinition);
2164
2165         ResourceMetadataDataDefinition resourceMetadaData = new ResourceMetadataDataDefinition();
2166         resourceMetadaData.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
2167         resourceMetadaData.setLastUpdaterUserId(user.getUserId());
2168         Resource resource = new Resource(new ResourceMetadataDefinition(resourceMetadaData));
2169         resource.setComponentInstances(componentInstanceList);
2170         resource.setUniqueId(componentId);
2171         resource.setInterfaces(interfaceDefinitions);
2172
2173         user.setRole(Role.ADMIN.name());
2174
2175         when(userValidations.validateUserExists(Mockito.eq("userId")))
2176                 .thenReturn(user);
2177         when(toscaOperationFacade.getToscaFullElement(any()))
2178                 .thenReturn(Either.left(resource));
2179         when(artifactToscaOperation.getArtifactById(any(), any(), any(), any()))
2180                 .thenReturn(Either.left(artifactDefinition));
2181         when(artifactsResolver.findArtifactOnComponent(any(), any(ComponentTypeEnum.class), anyString()))
2182                 .thenReturn(artifactDefinition);
2183         when(graphLockOperation.lockComponent(eq(resource.getUniqueId()), any(NodeTypeEnum.class)))
2184                 .thenReturn(StorageOperationStatus.OK);
2185         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), anyString(), any(NodeTypeEnum.class), any(), anyBoolean()))
2186                 .thenReturn(Either.left(artifactDefinition));
2187         when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
2188                 .thenReturn(CassandraOperationStatus.OK);
2189         when(toscaOperationFacade.getToscaElement(anyString()))
2190                 .thenReturn(Either.left(resource));
2191         when(interfaceOperation.updateInterfaces(anyString(), anyList()))
2192                 .thenReturn(Either.left(interfaceDefinitionsList));
2193         when(artifactToscaOperation.getAllInstanceArtifacts(resource.getUniqueId(), componentId)).thenReturn(Either.left(artifactDefinitionMap));
2194         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(any(), any())).thenReturn(StorageOperationStatus.OK);
2195
2196         Either<ArtifactDefinition, Operation> result = artifactBL.handleArtifactRequest(componentId, user.getUserId(), ComponentTypeEnum.RESOURCE_INSTANCE
2197                 , operationInfo, artifactDefinition.getUniqueId(), artifactDefinition, requestMd5, "data", "iuuid",
2198                 null, componentId, "resources");
2199
2200         assertThat(result.isLeft()).isTrue();
2201         ArtifactDefinition leftValue = result.left().value();
2202         assertEquals(artifactDefinition.getArtifactName(), leftValue.getArtifactName());
2203     }
2204
2205     @Test
2206     public void testGenerateToscaArtifact() {
2207
2208         Resource resource = new Resource();
2209         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2210         resource.setUniqueId("resourceId");
2211
2212         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2213         artifactDefinition.setUniqueId("artifactId");
2214         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_CSAR.getType());
2215         User user = new User();
2216         boolean inCertificationRequest = false;
2217         boolean fetchTemplatesFromDB = false;
2218         boolean shouldLock = false;
2219         boolean inTransaction = false;
2220
2221         byte[] csar = "test.csar".getBytes();
2222
2223         when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2224                 .thenReturn(Either.left(csar));
2225         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(Component.class), anyString(), any(NodeTypeEnum.class), anyString(), anyBoolean()))
2226                 .thenReturn(Either.left(artifactDefinition));
2227         when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
2228                 .thenReturn(CassandraOperationStatus.OK);
2229
2230         Either<ArtifactDefinition, Operation> result
2231                 = artifactBL.generateAndSaveToscaArtifact(artifactDefinition, resource, user, inCertificationRequest,
2232                 shouldLock, inTransaction, fetchTemplatesFromDB);
2233
2234
2235         Assert.assertEquals(artifactDefinition.getUniqueId(), result.left().value().getUniqueId());
2236     }
2237
2238     @Test
2239     public void testHandleDownloadToscaModelRequest() {
2240         ArtifactsBusinessLogic testSubject = getTestSubject();
2241         byte[] generatedCsar = "test.csar".getBytes();
2242
2243         Resource resource = new Resource();
2244         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2245
2246         ArtifactDefinition csarArtifact = new ArtifactDefinition();
2247         csarArtifact.setArtifactName("csarArtifact");
2248         csarArtifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.getType());
2249         csarArtifact.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2250
2251         when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2252                 .thenReturn(Either.left(generatedCsar));
2253
2254         ImmutablePair<String, byte[]> result =
2255                 testSubject.handleDownloadToscaModelRequest(resource, csarArtifact);
2256
2257         assertEquals(csarArtifact.getArtifactName(), result.getKey());
2258     }
2259
2260     @Test
2261     public void testHandleDownloadRequestById_returnsSuccessful() {
2262         String componentId = "componentId";
2263         String artifactId = "artifactId";
2264         String parentId = "parentId";
2265
2266         DAOArtifactData daoArtifactData = new DAOArtifactData();
2267         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2268         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2269         Operation operation = new Operation();
2270         operation.setUniqueId("op1");
2271
2272         artifactDefinition.setArtifactName("test.csar");
2273         artifactDefinition.setArtifactType(ComponentTypeEnum.RESOURCE.name());
2274         artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
2275         artifactDefinition.setUniqueId(artifactId);
2276         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2277
2278         daoArtifactData.setDataAsArray("data".getBytes());
2279
2280         Resource resource = new Resource();
2281         resource.setUniqueId("resourceId");
2282         resource.setAbstract(false);
2283
2284         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2285         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
2286         interfaceDefinitionMap.put("interDef1", interfaceDefinition);
2287
2288         artifactDefinitionMap.put("artifact1", artifactDefinition);
2289
2290         resource.setDeploymentArtifacts(artifactDefinitionMap);
2291
2292         User user = new User();
2293         user.setUserId("userId");
2294
2295         when(userValidations.validateUserExists(eq(user.getUserId())))
2296                 .thenReturn(user);
2297         when(toscaOperationFacade.getToscaFullElement(eq(componentId)))
2298                 .thenReturn(Either.left(resource));
2299         when(artifactToscaOperation.getArtifactById(anyString(), anyString(), any(ComponentTypeEnum.class), anyString()))
2300                 .thenReturn(Either.left(artifactDefinition));
2301         when(artifactCassandraDao.getArtifact(any()))
2302                 .thenReturn(Either.left(daoArtifactData));
2303         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
2304
2305         ImmutablePair<String, byte[]> result =
2306                 artifactBL.handleDownloadRequestById(componentId, artifactId, user.getUserId(), ComponentTypeEnum.RESOURCE,
2307                         parentId, null);
2308         Assert.assertEquals(artifactDefinition.getArtifactName(), result.getKey());
2309     }
2310
2311     @Test
2312     public void testHandleDownloadRequestById_givenUserIdIsNull_thenReturnsError() {
2313         String componentId = "componentId";
2314         String userId = null;
2315         String artifactId = "artifactId";
2316
2317         try {
2318             ImmutablePair<String, byte[]> result =
2319                     artifactBL.handleDownloadRequestById(componentId, artifactId, userId, ComponentTypeEnum.RESOURCE, componentId
2320                             , null);
2321         } catch (ComponentException e) {
2322             assertEquals(e.getActionStatus(), ActionStatus.MISSING_INFORMATION);
2323             return;
2324         }
2325         fail();
2326     }
2327
2328     @Test
2329     public void testHandleGetArtifactByType_returnsSuccessful() {
2330         String parentId = "parentId";
2331         String componentId = "componentId";
2332         String artifactGroupType = ArtifactGroupTypeEnum.OTHER.name();
2333         String userId = "userId";
2334
2335         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2336         artifactDefinition.setArtifactName("test.csar");
2337
2338         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2339         artifactDefinitionMap.put("artifact1", artifactDefinition);
2340
2341         Service service = new Service();
2342         service.setUniqueId(componentId);
2343
2344         when(toscaOperationFacade.getToscaElement(eq(componentId), any(ComponentParametersView.class)))
2345                 .thenReturn(Either.left(service));
2346         when(graphLockOperation.lockComponent(eq(componentId), any(NodeTypeEnum.class)))
2347                 .thenReturn(StorageOperationStatus.OK);
2348         when(artifactToscaOperation.getArtifacts(any(), any(NodeTypeEnum.class), any(ArtifactGroupTypeEnum.class), any()))
2349                 .thenReturn(Either.left(artifactDefinitionMap));
2350
2351         Map<String, ArtifactDefinition> result =
2352                 artifactBL.handleGetArtifactsByType(ComponentTypeEnum.SERVICE.name(), parentId, ComponentTypeEnum.SERVICE,
2353                         componentId, artifactGroupType, userId);
2354         Assert.assertEquals(artifactDefinition.getArtifactName(), result.get("artifact1").getArtifactName());
2355     }
2356
2357     @Test
2358     public void testGetDeployment_returnsSuccessful() {
2359
2360         Resource resource = new Resource();
2361         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2362         ComponentInstance componentInstance = new ComponentInstance();
2363         NodeTypeEnum parentType = NodeTypeEnum.ResourceInstance;
2364         String ciId = "ciId";
2365
2366         artifactDefinition.setArtifactName("test.csar");
2367         componentInstance.setUniqueId(ciId);
2368         List<ComponentInstance> componentInstanceList = new ArrayList<>();
2369         componentInstanceList.add(componentInstance);
2370
2371         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2372         deploymentArtifacts.put("test.csar", artifactDefinition);
2373
2374         resource.setDeploymentArtifacts(deploymentArtifacts);
2375         resource.setComponentInstances(componentInstanceList);
2376         componentInstance.setDeploymentArtifacts(deploymentArtifacts);
2377
2378         List<ArtifactDefinition> result = artifactBL.getDeploymentArtifacts(resource, ciId);
2379         assertThat(result.size() == 1).isTrue();
2380         Assert.assertEquals(artifactDefinition.getArtifactName(), result.get(0).getArtifactName());
2381     }
2382
2383     @Test
2384     public void testHandleDelete_returnsSuccessful() {
2385
2386         String parentId = "parentId";
2387         String artifactId = "artifactId";
2388         AuditingActionEnum auditingAction = AuditingActionEnum.ARTIFACT_DELETE;
2389         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2390         Resource resource = new Resource();
2391         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
2392         boolean shouldUnlock = true;
2393         boolean inTransaction = false;
2394         User user = new User();
2395
2396         artifactDefinition.setArtifactName("test.csar");
2397         artifactDefinition.setUniqueId(artifactId);
2398         artifactDefinition.setEsId("esId");
2399
2400         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
2401
2402         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2403         deploymentArtifacts.put(artifactId, artifactDefinition);
2404
2405         resource.setUniqueId(parentId);
2406         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2407         resource.setDeploymentArtifacts(deploymentArtifacts);
2408
2409         when(graphLockOperation.lockComponent(eq(parentId), any(NodeTypeEnum.class)))
2410                 .thenReturn(StorageOperationStatus.OK);
2411         when(toscaOperationFacade.getToscaElement(eq(parentId)))
2412                 .thenReturn(Either.left(resource));
2413         when(artifactToscaOperation.isCloneNeeded(any(), any(ArtifactDefinition.class), any(NodeTypeEnum.class)))
2414                 .thenReturn(Either.left(Boolean.FALSE));
2415         when(artifactToscaOperation.removeArtifactOnGraph(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class), anyBoolean()))
2416                 .thenReturn(Either.left(artifactDataDefinition));
2417         when(artifactCassandraDao.deleteArtifact(any()))
2418                 .thenReturn(CassandraOperationStatus.OK);
2419
2420         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result = artifactBL.handleDelete(parentId, artifactId, user, auditingAction, componentType, resource, shouldUnlock, inTransaction);
2421         Either<ArtifactDefinition, Operation> leftValue = result.left().value();
2422         Assert.assertEquals(artifactDefinition.getArtifactName(), leftValue.left().value().getArtifactName());
2423     }
2424
2425     @Test
2426     public void testDownloadRsrcArtifactByNames_givenServiceNameNull_thenReturnsError() {
2427         String serviceName = null;
2428         String serviceVersion = "2.0";
2429         String resourceName = "resource";
2430         String resourceVersion = "1.0";
2431         String artifactName = "artifactName";
2432
2433         try{
2434             artifactBL.downloadRsrcArtifactByNames(serviceName, serviceVersion, resourceName, resourceVersion, artifactName);
2435         } catch(ComponentException e) {
2436             assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
2437             return;
2438         }
2439         fail();
2440
2441     }
2442
2443     @Test
2444     public void testDownloadRsrcArtifactByNames_returnsSuccessful() {
2445
2446         String serviceName = "service1";
2447         String resourceName = "resource1";
2448         String artifactName = "artifact1";
2449         String version = "1.0";
2450
2451         Resource resource = new Resource();
2452         resource.setName(resourceName);
2453         resource.setVersion(version);
2454
2455         Service service = new Service();
2456         service.setVersion(version);
2457         service.setName(serviceName);
2458
2459         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2460         artifactDefinition.setEsId("esId");
2461
2462         DAOArtifactData esArtifactData = new DAOArtifactData();
2463         esArtifactData.setDataAsArray("test".getBytes());
2464
2465         artifactDefinition.setArtifactName(artifactName);
2466         List<Service> serviceList = new ArrayList<>();
2467         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2468         artifacts.put(artifactName, artifactDefinition);
2469
2470         serviceList.add(service);
2471         resource.setDeploymentArtifacts(artifacts);
2472
2473         when(toscaOperationFacade.getComponentByNameAndVersion(eq(ComponentTypeEnum.RESOURCE), eq(resourceName), eq(version), eq(JsonParseFlagEnum.ParseMetadata)))
2474                 .thenReturn(Either.left(resource));
2475         doReturn(Either.left(serviceList)).when(toscaOperationFacade).getBySystemName(eq(ComponentTypeEnum.SERVICE), eq(serviceName));
2476         when(artifactCassandraDao.getArtifact(any()))
2477                 .thenReturn(Either.left(esArtifactData));
2478
2479         byte[] result = artifactBL.downloadRsrcArtifactByNames(serviceName, version, resourceName, version, artifactName);
2480         Assert.assertEquals(esArtifactData.getDataAsArray(), result);
2481     }
2482
2483     private ArtifactsBusinessLogic getTestSubject() {
2484         final ArtifactsBusinessLogic artifactsBusinessLogic = new ArtifactsBusinessLogic(artifactCassandraDao,
2485             toscaExportHandler, csarUtils, lifecycleBusinessLogic,
2486             userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation,
2487             groupTypeOperation,
2488             interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
2489         artifactsBusinessLogic.setComponentsUtils(componentsUtils);
2490         return artifactsBusinessLogic;
2491     }
2492 }