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