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

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