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 testCheckArtifactInComponent() throws Exception {
 849         ArtifactsBusinessLogic testSubject;
 850         Component component = new Resource();
 851         component.setComponentType(ComponentTypeEnum.RESOURCE);
 852         String artifactId = "";
 853         boolean result;
 854
 855         // default test
 856         testSubject = createTestSubject();
 857         result = Deencapsulation.invoke(testSubject, "checkArtifactInComponent",
 858                 new Object[]{component, artifactId});
 859     }
 860
 861     @Test
 862     public void testCheckCreateFields() throws Exception {
 863         ArtifactsBusinessLogic testSubject;
 864         // User user = USER;
 865         ArtifactDefinition artifactInfo = buildArtifactPayload();
 866         ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
 867
 868         // default test
 869         testSubject = createTestSubject();
 870         Deencapsulation.invoke(testSubject, "checkCreateFields", user, artifactInfo, type);
 871     }
 872
 873     @Test
 874     public void testComposeArtifactId() throws Exception {
 875         ArtifactsBusinessLogic testSubject;
 876         String resourceId = "";
 877         String artifactId = "";
 878         ArtifactDefinition artifactInfo = buildArtifactPayload();
 879         String interfaceName = "";
 880         String operationName = "";
 881         String result;
 882
 883         // test 1
 884         testSubject = createTestSubject();
 885         result = Deencapsulation.invoke(testSubject, "composeArtifactId",
 886                 new Object[]{resourceId, artifactId, artifactInfo, interfaceName, operationName});
 887     }
 888
 889     @Test
 890     public void testConvertParentType() throws Exception {
 891         ArtifactsBusinessLogic testSubject;
 892         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 893         NodeTypeEnum result;
 894
 895         // default test
 896         testSubject = createTestSubject();
 897         result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[]{componentType});
 898     }
 899
 900     @Test
 901     public void testConvertToOperation() throws Exception {
 902         ArtifactsBusinessLogic testSubject;
 903         ArtifactDefinition artifactInfo = buildArtifactPayload();
 904         String operationName = "";
 905         Operation result;
 906
 907         // default test
 908         testSubject = createTestSubject();
 909         result = Deencapsulation.invoke(testSubject, "convertToOperation",
 910                 new Object[]{artifactInfo, operationName});
 911     }
 912
 913     @Test
 914     public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
 915         ArtifactsBusinessLogic testSubject;
 916         String operationName = "";
 917         String artifactName = "";
 918         String result;
 919
 920         // default test
 921         testSubject = createTestSubject();
 922         result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
 923                 new Object[]{operationName, artifactName});
 924     }
 925
 926     @Test
 927     public void testFetchArtifactsFromComponent() throws Exception {
 928         ArtifactsBusinessLogic testSubject;
 929         String artifactId = "";
 930         Component component = createResourceObject(true);
 931         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 932
 933         // default test
 934         testSubject = createTestSubject();
 935         Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
 936                 artifactId, component, artifacts);
 937     }
 938
 939
 940     @Test
 941     public void testValidateArtifact() throws Exception {
 942         ArtifactsBusinessLogic testSubject;
 943         String componentId = "";
 944         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 945         ArtifactsBusinessLogic arb = getTestSubject();
 946         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 947         String artifactId = "";
 948         ArtifactDefinition artifactInfo = buildArtifactPayload();
 949         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
 950
 951         Component component = createResourceObject(true);
 952         boolean shouldLock = false;
 953         boolean inTransaction = false;
 954
 955         // default test
 956         testSubject = createTestSubject();
 957         testSubject.validateArtifact(componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, shouldLock, inTransaction);
 958     }
 959
 960     @Test
 961     public void testHandleHeatEnvDownload() throws Exception {
 962         ArtifactsBusinessLogic testSubject;
 963         String componentId = "";
 964         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 965
 966         Component component = createResourceObject(true);
 967         ArtifactDefinition artifactInfo = buildArtifactPayload();
 968         boolean shouldLock = false;
 969         boolean inTransaction = false;
 970
 971
 972         // default test
 973         testSubject = createTestSubject();
 974         testSubject.handleHeatEnvDownload(componentId, componentType, user, component, artifactInfo, shouldLock, inTransaction);
 975     }
 976
 977     @Test
 978     public void testArtifactGenerationRequired() throws Exception {
 979         ArtifactsBusinessLogic testSubject;
 980         Component component = createResourceObject(true);
 981         ArtifactDefinition artifactInfo = buildArtifactPayload();
 982         boolean result;
 983
 984         // default test
 985         testSubject = createTestSubject();
 986         result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
 987                 new Object[]{component, artifactInfo});
 988     }
 989
 990     @Test
 991     public void testUpdateGroupForHeat() throws Exception {
 992         ArtifactsBusinessLogic testSubject;
 993         ArtifactDefinition artifactInfo = buildArtifactPayload();
 994         ArtifactDefinition artAfterUpdate = null;
 995         Component component = createResourceObject(true);
 996         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 997
 998         // default test
 999         testSubject = createTestSubject();
1000         testSubject.updateGroupForHeat(artifactInfo, artifactInfo, component);
1001     }
1002
1003     @Test
1004     public void testUpdateGroupForHeat_1() throws Exception {
1005         ArtifactsBusinessLogic testSubject;
1006         ArtifactDefinition artifactInfo = buildArtifactPayload();
1007         Component component = createResourceObject(true);
1008         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1009
1010         // default test
1011         testSubject = createTestSubject();
1012         testSubject.updateGroupForHeat(artifactInfo, artifactInfo, artifactInfo,
1013                 artifactInfo, component);
1014     }
1015
1016
1017     @Test
1018     public void testHandleAuditing() throws Exception {
1019         ArtifactsBusinessLogic testSubject;
1020         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1021         Component component = createResourceObject(true);
1022         String componentId = "";
1023
1024         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1025         String prevArtifactUuid = "";
1026         String currentArtifactUuid = "";
1027         ResponseFormat responseFormat = new ResponseFormat();
1028         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1029         String resourceInstanceName = "";
1030
1031         // test 1
1032         testSubject = createTestSubject();
1033         testSubject.setComponentsUtils(MockGenerator.mockComponentUtils());
1034         testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
1035                 prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
1036     }
1037
1038     @Test
1039     public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
1040         ArtifactsBusinessLogic testSubject;
1041         ArtifactsBusinessLogic arb = getTestSubject();
1042         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1043         ArtifactDefinition artifactInfo = buildArtifactPayload();
1044         ArtifactDefinition currentArtifactInfo = null;
1045
1046         // default test
1047         testSubject = createTestSubject();
1048         Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
1049                 operation, artifactInfo, artifactInfo);
1050     }
1051
1052     @Test
1053     public void testFindArtifactOnParentComponent() {
1054         ArtifactsBusinessLogic testSubject;
1055         Component component = createResourceObject(true);
1056         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1057         String parentId = "";
1058         ArtifactsBusinessLogic arb = getTestSubject();
1059         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1060         String artifactId = "";
1061         Either<ArtifactDefinition, ResponseFormat> result;
1062
1063         // default test
1064         testSubject = createTestSubject();
1065         result = Deencapsulation.invoke(testSubject, "findArtifact", new Object[]{component,
1066                 componentType, parentId, operation, artifactId});
1067     }
1068
1069
1070     @Test
1071     public void testValidateInformationalArtifact() throws Exception {
1072         ArtifactsBusinessLogic testSubject;
1073         ArtifactDefinition artifactInfo = buildArtifactPayload();
1074         Component component = createResourceObject(true);
1075         Either<Boolean, ResponseFormat> result;
1076
1077         // default test
1078         testSubject = createTestSubject();
1079         result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
1080                 new Object[]{artifactInfo, component});
1081     }
1082
1083
1084     @Test
1085     public void testGetUpdatedGroups() throws Exception {
1086         ArtifactsBusinessLogic testSubject;
1087         String artifactId = "";
1088         ArtifactDefinition artifactInfo = buildArtifactPayload();
1089         List<GroupDefinition> groups = new ArrayList<>();
1090         List<GroupDataDefinition> result;
1091
1092         // test 1
1093         testSubject = createTestSubject();
1094         result = Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
1095     }
1096
1097
1098     @Test
1099     public void testGetUpdatedGroupInstances() throws Exception {
1100         ArtifactsBusinessLogic testSubject;
1101         String artifactId = "";
1102         ArtifactDefinition artifactInfo = buildArtifactPayload();
1103         List<GroupDefinition> groups = new ArrayList<>();
1104         List<GroupInstance> result;
1105
1106         // default test
1107         testSubject = createTestSubject();
1108         result = Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
1109     }
1110
1111
1112     @Test
1113     public void testFindArtifact_1() throws Exception {
1114         ArtifactsBusinessLogic testSubject;
1115         String artifactId = "";
1116         Component component = createResourceObject(true);
1117         String parentId = "";
1118         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1119         Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> result;
1120
1121         // default test
1122         testSubject = createTestSubject();
1123         result = Deencapsulation.invoke(testSubject, "findArtifact",
1124                 new Object[]{artifactId, component, parentId, componentType});
1125     }
1126
1127
1128     @Test
1129     public void testFetchArtifactsFromInstance() throws Exception {
1130         ArtifactsBusinessLogic testSubject;
1131         String artifactId = "";
1132         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1133         ComponentInstance instance = new ComponentInstance();
1134
1135
1136         // default test
1137         testSubject = createTestSubject();
1138         Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
1139     }
1140
1141
1142     @Test
1143     public void testGenerateCustomizationUUIDOnInstance() throws Exception {
1144         ArtifactsBusinessLogic testSubject;
1145         String componentId = "";
1146         String instanceId = "";
1147         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1148         StorageOperationStatus result;
1149
1150         // default test
1151         testSubject = createTestSubject();
1152         result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
1153                 new Object[]{componentId, instanceId, componentType});
1154     }
1155
1156     @Test
1157     public void testFindComponentInstance() {
1158         ArtifactsBusinessLogic testSubject;
1159         String componentInstanceId = "";
1160         Component component = createResourceObject(true);
1161         ComponentInstance result;
1162
1163         // default test
1164         testSubject = createTestSubject();
1165         result = Deencapsulation.invoke(testSubject, "findComponentInstance",
1166                 new Object[]{componentInstanceId, component});
1167     }
1168
1169     @Test(expected = ComponentException.class)
1170     public void testDeploymentArtifactTypeIsLegalForParent_shouldThrowException() {
1171         ArtifactsBusinessLogic testSubject;
1172         ArtifactDefinition artifactInfo = buildArtifactPayload();
1173         ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
1174         Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts = new HashMap<>();
1175         // test 1
1176         testSubject = createTestSubject();
1177         testSubject.validateDeploymentArtifactTypeIsLegalForParent(artifactInfo, artifactType, resourceDeploymentArtifacts);
1178     }
1179
1180     @Test
1181     public void testLoadArtifactTypeConfig() {
1182         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1183         //null artifactType
1184         Optional<ArtifactConfiguration> artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(null);
1185         assertThat(artifactConfiguration.isPresent()).isFalse();
1186         //not configured artifactType
1187         artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig("NotConfiguredArtifactType");
1188         assertThat(artifactConfiguration.isPresent()).isFalse();
1189
1190         //valid artifactType
1191         final String artifactType = ArtifactTypeEnum.YANG.getType();
1192         artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(artifactType);
1193         assertThat(artifactConfiguration.isPresent()).isTrue();
1194         final ArtifactConfiguration artifactConfiguration1 = artifactConfiguration.get();
1195         assertThat(artifactConfiguration1.getType()).isEqualTo(artifactType);
1196         assertThat(artifactConfiguration1.getCategories()).hasSize(1);
1197         assertThat(artifactConfiguration1.getCategories()).contains(ArtifactGroupTypeEnum.INFORMATIONAL);
1198         assertThat(artifactConfiguration1.getComponentTypes()).hasSize(1);
1199         assertThat(artifactConfiguration1.getComponentTypes()).contains(ComponentType.RESOURCE);
1200         assertThat(artifactConfiguration1.getResourceTypes()).hasSize(7);
1201         assertThat(artifactConfiguration1.getResourceTypes())
1202             .contains(ResourceTypeEnum.VFC.getValue(), ResourceTypeEnum.CP.getValue(), ResourceTypeEnum.VL.getValue(),
1203                 ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.VFCMT.getValue(), "Abstract",
1204                 ResourceTypeEnum.CVFC.getValue());
1205     }
1206
1207     @Test
1208     public void testValidateArtifactExtension_acceptedExtension() {
1209         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1210         artifactInfo.setArtifactName("artifact.yml");
1211         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1212         //empty accepted types
1213         assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(new ArtifactConfiguration(), artifactInfo))
1214             .doesNotThrowAnyException();
1215
1216         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1217         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1218         assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo))
1219             .doesNotThrowAnyException();
1220     }
1221
1222     @Test(expected = ComponentException.class)
1223     public void testValidateArtifactExtension_notAcceptedExtension() {
1224         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1225         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1226         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1227         //not accepted extension
1228         artifactInfo.setArtifactName("artifact.xml");
1229
1230         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1231
1232         artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1233     }
1234
1235     @Test(expected = ComponentException.class)
1236     public void testValidateArtifactExtension_noExtension() {
1237         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1238         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1239         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1240         //no extension in the artifact name
1241         artifactInfo.setArtifactName("artifact");
1242
1243         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1244
1245         artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1246     }
1247
1248     @Test(expected = ComponentException.class)
1249     public void testValidateHeatEnvDeploymentArtifact_shouldThrowException() {
1250         ArtifactsBusinessLogic testSubject;
1251         Component component = createResourceObject(true);
1252         String parentId = "";
1253         ArtifactDefinition artifactInfo = buildArtifactPayload();
1254         // default test
1255         testSubject = createTestSubject();
1256         testSubject.validateHeatEnvDeploymentArtifact(component, parentId, artifactInfo);
1257     }
1258
1259     @Test
1260     public void testFillArtifactPayloadValidation() throws Exception {
1261         ArtifactsBusinessLogic testSubject;
1262         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1263         Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1264         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1265
1266         // default test
1267         testSubject = createTestSubject();
1268         testSubject.fillArtifactPayload(payloadWrapper, artifactDefinition);
1269     }
1270
1271
1272
1273     @Test
1274     public void testIsValidXml() throws Exception {
1275         ArtifactsBusinessLogic testSubject;
1276         byte[] xmlToParse = new byte[]{' '};
1277         boolean result;
1278
1279         // default test
1280         testSubject = createTestSubject();
1281         result = Deencapsulation.invoke(testSubject, "isValidXml", new Object[]{xmlToParse});
1282     }
1283
1284     @Test(expected = ByActionStatusComponentException.class)
1285     public void testHeatTimeoutValue() {
1286         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1287         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1288         artifactInfo.setTimeout(1);
1289         artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1290         artifactInfo.setTimeout(0);
1291         artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1292     }
1293
1294     @Test
1295     public void testValidateResourceType_resourceTypeIsAccepted() {
1296         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1297         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1298         final List<String> typeList = Arrays
1299             .asList(ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.PNF.getValue(), ResourceTypeEnum.VFC.getValue());
1300         assertThatCode(() -> {
1301             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1302         }).doesNotThrowAnyException();
1303     }
1304
1305     @Test(expected=ComponentException.class)
1306     public void testValidateResourceType_invalidResourceType() {
1307         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1308         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1309         final List<String> typeList = Collections.singletonList(ResourceTypeEnum.PNF.getValue());
1310         artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1311     }
1312
1313     @Test
1314     public void testValidateResourceType_emptyResourceTypeConfig_resourceTypeIsAccepted() {
1315         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1316         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1317         assertThatCode(() -> {
1318             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, null);
1319         }).doesNotThrowAnyException();
1320         assertThatCode(() -> {
1321             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, new ArrayList<>());
1322         }).doesNotThrowAnyException();
1323     }
1324
1325     @Test
1326     public void testValidateAndConvertHeatParameters() throws Exception {
1327         ArtifactsBusinessLogic testSubject;
1328         ArtifactDefinition artifactInfo = buildArtifactPayload();
1329         String artifactType = "";
1330         Either<ArtifactDefinition, ResponseFormat> result;
1331
1332         // default test
1333         testSubject = createTestSubject();
1334         testSubject.validateAndConvertHeatParameters(artifactInfo, artifactType);
1335     }
1336
1337     @Test
1338     public void testGetDeploymentArtifacts() throws Exception {
1339         ArtifactsBusinessLogic testSubject;
1340         Component component = createResourceObject(true);
1341         NodeTypeEnum parentType = null;
1342         String ciId = "";
1343         List<ArtifactDefinition> result;
1344
1345         // default test
1346         testSubject = createTestSubject();
1347         result = testSubject.getDeploymentArtifacts(component, ciId);
1348     }
1349
1350
1351     @Test
1352     public void testValidateFirstUpdateHasPayload() throws Exception {
1353         ArtifactsBusinessLogic testSubject;
1354         ArtifactDefinition artifactInfo = buildArtifactPayload();
1355         ArtifactDefinition currentArtifact = null;
1356         Either<Boolean, ResponseFormat> result;
1357
1358         // default test
1359         testSubject = createTestSubject();
1360         result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1361                 new Object[]{artifactInfo, artifactInfo});
1362     }
1363
1364     @Test
1365     public void testValidateAndSetArtifactname() throws Exception {
1366         ArtifactsBusinessLogic testSubject;
1367         ArtifactDefinition artifactInfo = buildArtifactPayload();
1368         Either<Boolean, ResponseFormat> result;
1369
1370         // default test
1371         testSubject = createTestSubject();
1372         testSubject.validateAndSetArtifactName(artifactInfo);
1373     }
1374
1375     @Test(expected = ComponentException.class)
1376     public void testValidateArtifactType_notConfiguredArtifactType() {
1377         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1378         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1379         artifactInfo.setArtifactType("notConfiguredType");
1380         Deencapsulation
1381             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1382     }
1383
1384     @Test(expected = ComponentException.class)
1385     public void testValidateArtifactType_componentTypeNotSupportedByArtifactType() {
1386         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1387         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1388         artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1389
1390         Deencapsulation
1391             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1392     }
1393
1394     @Test(expected = ComponentException.class)
1395     public void testValidateArtifactType_groupTypeNotSupportedByArtifactType() {
1396         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1397         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1398         artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1399         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1400
1401         Deencapsulation
1402             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.SERVICE);
1403     }
1404
1405     @Test
1406     public void testValidateArtifactTypeNotChanged() throws Exception {
1407         ArtifactsBusinessLogic testSubject;
1408         ArtifactDefinition artifactInfo = buildArtifactPayload();
1409         ArtifactDefinition currentArtifact = null;
1410         Either<Boolean, ResponseFormat> result;
1411
1412         // default test
1413         testSubject = createTestSubject();
1414         result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1415                 new Object[]{artifactInfo, artifactInfo});
1416     }
1417
1418
1419     @Test
1420     public void testValidateOrSetArtifactGroupType() throws Exception {
1421         ArtifactsBusinessLogic testSubject;
1422         ArtifactDefinition artifactInfo = buildArtifactPayload();
1423         ArtifactDefinition currentArtifact = null;
1424         Either<ArtifactDefinition, ResponseFormat> result;
1425
1426         // default test
1427         testSubject = createTestSubject();
1428         result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1429                 new Object[]{artifactInfo, artifactInfo});
1430     }
1431
1432     @Test
1433     public void testCheckAndSetUnUpdatableFields() throws Exception {
1434         ArtifactsBusinessLogic testSubject;
1435
1436         ArtifactDefinition artifactInfo = buildArtifactPayload();
1437         ArtifactDefinition currentArtifact = null;
1438         ArtifactGroupTypeEnum type = null;
1439
1440         // test 1
1441         testSubject = createTestSubject();
1442         type = null;
1443         Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", user,
1444                 artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class);
1445     }
1446
1447     @Test
1448     public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1449         ArtifactsBusinessLogic testSubject;
1450         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1451         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1452
1453
1454         // default test
1455         testSubject = createTestSubject();
1456         Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1457     }
1458
1459     @Test
1460     public void testGetMapOfParameters() throws Exception {
1461         ArtifactsBusinessLogic testSubject;
1462         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1463         Map<String, HeatParameterDefinition> result;
1464
1465         // default test
1466         testSubject = createTestSubject();
1467         result = Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1468     }
1469
1470     @Test
1471     public void testGivenValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1472         final byte[] payload = "validYaml: yes".getBytes();
1473         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1474
1475         final boolean isArtifactMetadataUpdate = false;
1476         ArtifactsBusinessLogic testSubject = getTestSubject();
1477
1478         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1479                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1480         assertArrayEquals(payload, result.left().value());
1481     }
1482
1483
1484
1485
1486
1487     @Test
1488         public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1489                 final int expectedStatus = 100;
1490                 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1491                 final byte[] payload = "invalidYaml".getBytes();
1492                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1493
1494         final boolean isArtifactMetadataUpdate = false;
1495         ArtifactsBusinessLogic testSubject = getTestSubject();
1496         testSubject.setComponentsUtils(componentsUtils);
1497
1498         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1499                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1500
1501         int status = result.right().value().getStatus();
1502         assertEquals(expectedStatus, status);
1503     }
1504
1505     @Test
1506         public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
1507                 final int expectedStatus = 101;
1508                 when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1509                 final byte[] payload = "".getBytes();
1510                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1511
1512         final boolean isArtifactMetadataUpdate = false;
1513         ArtifactsBusinessLogic testSubject = getTestSubject();
1514         testSubject.setComponentsUtils(componentsUtils);
1515
1516         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1517                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1518
1519                 int status = result.right().value().getStatus();
1520                 assertEquals(expectedStatus, status);
1521     }
1522
1523
1524     @Test
1525         public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1526                 final byte[] payload = "heat_template_version: 1.0".getBytes();
1527                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1528
1529         final boolean isArtifactMetadataUpdate = false;
1530         ArtifactsBusinessLogic testSubject = getTestSubject();
1531
1532         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1533                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1534         assertArrayEquals(payload, result.left().value());
1535     }
1536
1537     @Test
1538         public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1539                 final int expectedStatus = 1000;
1540                 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1541                 final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
1542                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1543
1544         final boolean isArtifactMetadataUpdate = false;
1545         ArtifactsBusinessLogic testSubject = getTestSubject();
1546         testSubject.setComponentsUtils(componentsUtils);
1547
1548         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1549                 new Object[]{artifactInfo, isArtifactMetadataUpdate});
1550
1551         int status = result.right().value().getStatus();
1552         assertEquals(expectedStatus, status);
1553     }
1554
1555     private ArtifactDefinition createArtifactInfo(byte[] payload, String artifactName, ArtifactTypeEnum artifactType) {
1556         ArtifactDefinition artifactInfo = new ArtifactDefinition();
1557         artifactInfo.setArtifactName(artifactName);
1558         artifactInfo.setArtifactType(artifactType.getType());
1559         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1560         artifactInfo.setPayload(Base64.encodeBase64(payload));
1561         return artifactInfo;
1562     }
1563
1564     @Test
1565     public void testValidateUserRole() throws Exception {
1566         ArtifactsBusinessLogic testSubject;
1567
1568         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
1569         String componentId = "";
1570         String artifactId = "";
1571         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1572         ArtifactsBusinessLogic arb = getTestSubject();
1573         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1574         Either<Boolean, ResponseFormat> result;
1575
1576         // default test
1577         testSubject = createTestSubject();
1578         result = Deencapsulation.invoke(testSubject, "validateUserRole",
1579                 new Object[]{user, auditingAction, componentId, artifactId, componentType,
1580                         operation});
1581         assertNull(result);
1582     }
1583
1584     @Test
1585     public void testDetectAuditingType() throws Exception {
1586         ArtifactsBusinessLogic testSubject;
1587         ArtifactsBusinessLogic arb = getTestSubject();
1588         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
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         assertNotNull(result);
1597     }
1598
1599     @Test
1600     public void testDetectNoAuditingType() throws Exception {
1601         ArtifactsBusinessLogic testSubject;
1602         ArtifactsBusinessLogic arb = getTestSubject();
1603         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.LINK);
1604         String origMd5 = "";
1605         AuditingActionEnum result;
1606
1607         // default test
1608         testSubject = createTestSubject();
1609         result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1610                 new Object[]{operation, origMd5});
1611         assertNull(result);
1612     }
1613
1614     @Test
1615     public void testCreateEsArtifactData() throws Exception {
1616         ArtifactsBusinessLogic testSubject;
1617         ArtifactDataDefinition artifactInfo = buildArtifactPayload();
1618         byte[] artifactPayload = new byte[]{' '};
1619         DAOArtifactData result;
1620
1621         // default test
1622         testSubject = createTestSubject();
1623         result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1624         assertNotNull(result);
1625     }
1626
1627
1628     @Test
1629     public void testIsArtifactMetadataUpdateTrue() throws Exception {
1630         ArtifactsBusinessLogic testSubject;
1631         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ARTIFACT_METADATA_UPDATE;
1632         boolean result;
1633
1634         // default test
1635         testSubject = createTestSubject();
1636         result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1637                 new Object[]{auditingActionEnum});
1638         assertThat(result).isTrue();
1639     }
1640
1641     @Test
1642     public void testIsArtifactMetadataUpdateFalse() throws Exception {
1643         ArtifactsBusinessLogic testSubject;
1644         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1645         boolean result;
1646
1647         // default test
1648         testSubject = createTestSubject();
1649         result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1650                 new Object[]{auditingActionEnum});
1651         assertThat(result).isFalse();
1652     }
1653
1654     @Test
1655     public void testIsDeploymentArtifactTrue() throws Exception {
1656         ArtifactsBusinessLogic testSubject;
1657         ArtifactDefinition artifactInfo = buildArtifactPayload();
1658         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1659         boolean result;
1660
1661         // default test
1662         testSubject = createTestSubject();
1663         result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1664         assertThat(result).isTrue();
1665     }
1666
1667     @Test
1668     public void testIsDeploymentArtifactFalse() throws Exception {
1669         ArtifactsBusinessLogic testSubject;
1670         ArtifactDefinition artifactInfo = buildArtifactPayload(); // artifactGroupType == ArtifactGroupTypeEnum.TOSCA
1671         boolean result;
1672
1673         // default test
1674         testSubject = createTestSubject();
1675         result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1676         assertThat(result).isFalse();
1677     }
1678
1679     @Test
1680     public void testSetArtifactPlaceholderCommonFields() throws Exception {
1681         ArtifactsBusinessLogic testSubject;
1682         String resourceId = ES_ARTIFACT_ID;
1683
1684         ArtifactDefinition artifactInfo = buildArtifactPayload();
1685
1686         // test 1
1687         testSubject = createTestSubject();
1688         Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1689                 resourceId, user, artifactInfo);
1690         assertEquals(resourceId + "." +ARTIFACT_LABEL, artifactInfo.getUniqueId());
1691         assertEquals(user.getFullName(), artifactInfo.getCreatorFullName());
1692     }
1693
1694
1695     @Test
1696     public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1697         ArtifactsBusinessLogic testSubject;
1698         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1699         String payloadStr = "";
1700         Either<DAOArtifactData, ResponseFormat> result;
1701
1702         // default test
1703         testSubject = createTestSubject();
1704         result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1705                 new Object[]{artifactDefinition, payloadStr});
1706         assertThat(result.isLeft()).isTrue();
1707     }
1708
1709     @Test
1710     public void testUpdateArtifactOnGroupInstance() throws Exception {
1711         ArtifactsBusinessLogic testSubject;
1712         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1713         Component component = createResourceObject(true);
1714         String instanceId = "";
1715         String prevUUID = "";
1716         ArtifactDefinition artifactInfo = buildArtifactPayload();
1717         Either<ArtifactDefinition, ResponseFormat> result;
1718
1719         // test 1
1720         testSubject = createTestSubject();
1721         result = testSubject.updateArtifactOnGroupInstance(component, instanceId, prevUUID, artifactInfo, artifactInfo);
1722         assertThat(result.isLeft()).isTrue();
1723     }
1724
1725     @Test
1726     public void testGenerateHeatEnvPayload() throws Exception {
1727         ArtifactsBusinessLogic testSubject;
1728         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1729         String result;
1730
1731         // default test
1732         testSubject = createTestSubject();
1733         result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1734                 new Object[]{artifactDefinition});
1735         assertThat(result.isEmpty()).isFalse();
1736     }
1737
1738
1739     @Test
1740     public void testBuildJsonForUpdateArtifact() throws Exception {
1741         ArtifactsBusinessLogic testSubject;
1742         ArtifactDefinition artifactInfo = buildArtifactPayload();
1743         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1744         List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1745         Map<String, Object> result;
1746
1747         // default test
1748         testSubject = createTestSubject();
1749         result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1750         assertThat(MapUtils.isNotEmpty(result)).isTrue();
1751     }
1752
1753     @Test
1754     public void testBuildJsonForUpdateArtifact_1() throws Exception {
1755         ArtifactsBusinessLogic testSubject;
1756         String artifactId = "";
1757         String artifactName = "";
1758         String artifactType = "";
1759         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1760         String label = "";
1761         String displayName = "";
1762         String description = "";
1763         byte[] artifactContent = new byte[]{' '};
1764         List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1765         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1766         Map<String, Object> result;
1767
1768         // test 1
1769         testSubject = createTestSubject();
1770         artifactId = "";
1771         result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1772                 label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1773         assertThat(MapUtils.isNotEmpty(result)).isTrue();
1774     }
1775
1776
1777     @Test
1778     public void testNotReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1779         ArtifactsBusinessLogic testSubject;
1780         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1781         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1782
1783
1784         // default test
1785         testSubject = createTestSubject();
1786         boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1787         assertThat(result).isFalse();
1788     }
1789
1790
1791     @Test
1792     public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1793         ArtifactsBusinessLogic testSubject;
1794         HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1795         hpdOrig.setName("param1");
1796         hpdOrig.setCurrentValue("value1");
1797
1798         HeatParameterDefinition hpdUpd = new HeatParameterDefinition();
1799         hpdUpd.setName("param1");
1800         hpdUpd.setCurrentValue("value2");
1801
1802         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1803         currentHeatEnvParams.add(hpdOrig);
1804
1805         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1806         updatedHeatEnvParams.add(hpdUpd);
1807
1808         // default test
1809         testSubject = createTestSubject();
1810         boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1811         assertThat(result).isTrue();
1812         assertEquals(hpdUpd.getCurrentValue(), hpdOrig.getCurrentValue());
1813     }
1814
1815
1816     @Test
1817     public void testExtractArtifactDefinition() throws Exception {
1818         ArtifactsBusinessLogic testSubject;
1819         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1820         Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1821         ArtifactDefinition result;
1822
1823         // default test
1824         testSubject = createTestSubject();
1825         result = testSubject.extractArtifactDefinition(eitherArtifact);
1826         assertNotNull(result);
1827         assertEquals(artifactDefinition, result);
1828     }
1829
1830
1831     @Test
1832     public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1833         ArtifactsBusinessLogic testSubject;
1834         ArtifactDefinition artifact = buildArtifactPayload();
1835         ArtifactDefinition artifactInfo = new ArtifactDefinition();
1836
1837         HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1838         hpdOrig.setName("param1");
1839         hpdOrig.setCurrentValue("value1");
1840         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1841         currentHeatEnvParams.add(hpdOrig);
1842         artifact.setListHeatParameters(currentHeatEnvParams);
1843
1844         // default test
1845         testSubject = createTestSubject();
1846         Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1847                 artifact, artifactInfo);
1848
1849         assertNotEquals(artifact, artifactInfo);
1850         assertEquals(1, artifact.getListHeatParameters().size());
1851         assertEquals(1, artifactInfo.getListHeatParameters().size());
1852
1853         String hpdOrigCurrValue = artifact.getListHeatParameters().get(0).getCurrentValue();
1854         String hpdNewDefaultValue = artifactInfo.getListHeatParameters().get(0).getDefaultValue();
1855
1856         assertEquals(hpdOrigCurrValue, hpdNewDefaultValue);
1857     }
1858
1859     @Test
1860     public void testBuildHeatEnvFileNameArtifactNameNotNull() throws Exception {
1861         String heatEnvExt = "zip";
1862         ArtifactsBusinessLogic testSubject;
1863         ArtifactDefinition heatArtifact = buildArtifactPayload();
1864         ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1865         Map<String, Object> placeHolderData = new HashMap<>();
1866         placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1867         String artName = ARTIFACT_NAME.split("\\.")[0];
1868
1869         // default test
1870         testSubject = createTestSubject();
1871         Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1872         assertThat(heatEnvArtifact.getArtifactName().startsWith(artName)).isTrue();
1873         assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1874     }
1875
1876     @Test
1877     public void testBuildHeatEnvFileNameArtifactNameIsNull() throws Exception {
1878         String heatEnvExt = "zip";
1879         ArtifactsBusinessLogic testSubject;
1880         ArtifactDefinition heatArtifact = buildArtifactPayload();
1881         heatArtifact.setArtifactName(null);
1882         ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1883         Map<String, Object> placeHolderData = new HashMap<>();
1884         placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1885
1886         // default test
1887         testSubject = createTestSubject();
1888         Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1889         assertThat(heatEnvArtifact.getArtifactName().startsWith(ARTIFACT_LABEL)).isTrue();
1890         assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1891     }
1892
1893     @Test
1894     public void testHandleEnvArtifactVersion() throws Exception {
1895         ArtifactsBusinessLogic testSubject;
1896         String existingVersion = "1.0";
1897         ArtifactDefinition artifactInfo = buildArtifactPayload();
1898         Map<String, String> existingEnvVersions = new HashMap<>();
1899         existingEnvVersions.put(artifactInfo.getArtifactName(), existingVersion);
1900
1901         // test 1
1902         testSubject = createTestSubject();
1903         Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", artifactInfo, existingEnvVersions);
1904         assertEquals(existingVersion, artifactInfo.getArtifactVersion());
1905     }
1906
1907     @Test
1908     public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1909         ArtifactsBusinessLogic testSubject;
1910         List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();
1911         Resource component = createResourceObject(true);
1912
1913         List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();
1914         ArtifactsBusinessLogic arb = getTestSubject();
1915         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1916         boolean shouldLock = false;
1917         boolean inTransaction = false;
1918         List<ArtifactDefinition> result;
1919
1920         // default test
1921         testSubject = createTestSubject();
1922         result = testSubject.handleArtifactsForInnerVfcComponent(artifactsToHandle, component, user,
1923                 vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1924
1925         assertThat(CollectionUtils.isEmpty(result)).isTrue();
1926     }
1927
1928     @Test
1929     public void testSetNodeTemplateOperation() throws Exception {
1930         ArtifactsBusinessLogic testSubject;
1931         NodeTemplateOperation nodeTemplateOperation = new NodeTemplateOperation();
1932
1933         // default test
1934         testSubject = createTestSubject();
1935         Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", nodeTemplateOperation);
1936         assertEquals(Deencapsulation.getField(testSubject, "nodeTemplateOperation"), nodeTemplateOperation);
1937     }
1938
1939
1940     @Test(expected = ComponentException.class)
1941     public void validateDeploymentArtifact_invalidComponentType() {
1942         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1943         Component component = new Resource();
1944         component.setComponentType(ComponentTypeEnum.PRODUCT);
1945         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1946         Deencapsulation
1947             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1948     }
1949
1950     @Test(expected = ComponentException.class)
1951     public void validateDeploymentArtifact_notConfiguredArtifactType() {
1952         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1953         Component component = new Resource();
1954         component.setComponentType(ComponentTypeEnum.RESOURCE);
1955         artifactDefinition.setArtifactType("NotConfiguredType");
1956         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1957         Deencapsulation
1958             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1959     }
1960
1961     @Test(expected = ComponentException.class)
1962     public void validateDeploymentArtifact_unsupportedResourceType() {
1963         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1964         artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
1965         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1966         final Resource resourceComponent = new Resource();
1967         resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1968         resourceComponent.setResourceType(ResourceTypeEnum.ServiceProxy);
1969         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1970         Deencapsulation
1971             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1972     }
1973
1974     @Test
1975     public void validateDeploymentArtifact_validArtifact() {
1976         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1977         artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
1978         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1979         final Resource resourceComponent = new Resource();
1980         resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1981         resourceComponent.setResourceType(ResourceTypeEnum.VF);
1982         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1983         assertThatCode(() -> {
1984             Deencapsulation
1985                 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1986         }).doesNotThrowAnyException();
1987
1988     }
1989
1990     @Test
1991     public void validateHeatArtifact_validArtifact() {
1992         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1993         artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
1994         artifactDefinition.setTimeout(1);
1995         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1996         assertThatCode(() -> {
1997             Deencapsulation
1998                 .invoke(artifactsBusinessLogic, "validateHeatArtifact", new Resource(), "componentId", artifactDefinition);
1999         }).doesNotThrowAnyException();
2000     }
2001
2002     @Test
2003     public void validateInputForResourceInstance() {
2004         final String artifactId = "artifactId";
2005         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2006         artifactDefinition.setUniqueId(artifactId);
2007         artifactDefinition.setArtifactName(ARTIFACT_NAME);
2008         artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
2009         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
2010         artifactDefinition.setEsId(ES_ARTIFACT_ID);
2011         artifactDefinition.setPayload(PAYLOAD);
2012         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
2013         artifactDefinition.setDescription("artifact description");
2014         artifactDefinition.setServiceApi(true);
2015         artifactDefinition.setApiUrl("dumbUrl");
2016
2017         final User user = new User();
2018         user.setUserId("userId");
2019         user.setRole(Role.ADMIN.name());
2020
2021         final String parentId = "parentId";
2022         final Service service = new Service();
2023         service.setComponentType(ComponentTypeEnum.SERVICE);
2024         service.setUniqueId(parentId);
2025         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2026         service.setLastUpdaterUserId(user.getUserId());
2027
2028         final ArtifactOperationInfo operationInfo =
2029             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2030
2031         final String componentId = "componentId";
2032         final ComponentInstance componentInstance = new ComponentInstance();
2033         componentInstance.setUniqueId(componentId);
2034         componentInstance.setComponentUid(componentId);
2035         service.setComponentInstances(Collections.singletonList(componentInstance));
2036
2037         final Resource resource = new Resource();
2038         when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2039         when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2040
2041         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2042         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2043         Object result = Deencapsulation
2044             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2045                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2046         assertTrue(result instanceof Either<?, ?>);
2047         assertTrue(((Either<?, ?>) result).isLeft());
2048
2049         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2050
2051         result = Deencapsulation
2052             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2053                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2054         assertTrue(result instanceof Either<?, ?>);
2055         assertTrue(((Either<?, ?>) result).isLeft());
2056     }
2057
2058     @Test
2059     public void validateInputForResourceInstanceDeploymentArtifact() {
2060         final String artifactId = "artifactId";
2061         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2062         artifactDefinition.setUniqueId(artifactId);
2063         artifactDefinition.setArtifactName(ARTIFACT_NAME);
2064         artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
2065         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
2066         artifactDefinition.setEsId(ES_ARTIFACT_ID);
2067         artifactDefinition.setPayload(PAYLOAD);
2068         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2069         artifactDefinition.setDescription("artifact description");
2070
2071         final User user = new User();
2072         user.setUserId("userId");
2073         user.setRole(Role.ADMIN.name());
2074
2075         final String parentId = "parentId";
2076         final Service service = new Service();
2077         service.setComponentType(ComponentTypeEnum.SERVICE);
2078         service.setUniqueId(parentId);
2079         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2080         service.setLastUpdaterUserId(user.getUserId());
2081
2082         final ArtifactOperationInfo operationInfo =
2083             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2084
2085         final String componentId = "componentId";
2086         final ComponentInstance componentInstance = new ComponentInstance();
2087         componentInstance.setUniqueId(componentId);
2088         componentInstance.setComponentUid(componentId);
2089         service.setComponentInstances(Collections.singletonList(componentInstance));
2090
2091         final Resource resource = new Resource();
2092         when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2093         when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2094
2095         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2096         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2097
2098         final Object result = Deencapsulation
2099             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2100                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2101         assertTrue(result instanceof Either<?, ?>);
2102         assertTrue(((Either<?, ?>) result).isLeft());
2103     }
2104
2105
2106     @Test
2107     public void testHandleArtifactRequest() {
2108
2109         String componentId = "componentId";
2110         ArtifactOperationInfo operationInfo = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE);
2111         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2112         artifactDefinition.setArtifactName("other");
2113         artifactDefinition.setUniqueId("artifactId");
2114         artifactDefinition.setPayload("Test".getBytes());
2115         artifactDefinition.setArtifactLabel("other");
2116         artifactDefinition.setDescription("Test artifact");
2117         artifactDefinition.setArtifactType(ArtifactTypeEnum.OTHER.getType());
2118         artifactDefinition.setArtifactUUID("artifactUId");
2119         artifactDefinition.setArtifactLabel("test");
2120         artifactDefinition.setArtifactDisplayName("Test");
2121         artifactDefinition.setEsId("esId");
2122
2123         String requestMd5 = GeneralUtility.calculateMD5Base64EncodedByString("data");
2124         User user = new User();
2125         user.setUserId("userId");
2126
2127         List<ComponentInstance> componentInstanceList = new ArrayList<>();
2128         List<InterfaceDefinition> interfaceDefinitionsList = new ArrayList<>();
2129         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2130         Map<String, Operation> operationsMap = new HashMap<>();
2131         artifactDefinitionMap.put("sample", artifactDefinition);
2132
2133         ComponentInstance componentInstance = new ComponentInstance();
2134         componentInstance.setUniqueId(componentId);
2135         componentInstance.setDeploymentArtifacts(artifactDefinitionMap);
2136         componentInstanceList.add(componentInstance);
2137
2138         Operation operation = new Operation();
2139         operation.setUniqueId("ouuid");
2140         operation.setName("operation1");
2141         operation.setImplementation(artifactDefinition);
2142         operationsMap.put("op1", operation);
2143
2144         Map<String, InterfaceDefinition> interfaceDefinitions = new HashMap<>();
2145
2146         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2147         interfaceDefinition.setType("iuuid");
2148         interfaceDefinition.setOperationsMap(operationsMap);
2149         interfaceDefinitions.put("iuuid", interfaceDefinition);
2150
2151         interfaceDefinitionsList.add(interfaceDefinition);
2152
2153         ResourceMetadataDataDefinition resourceMetadaData = new ResourceMetadataDataDefinition();
2154         resourceMetadaData.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
2155         resourceMetadaData.setLastUpdaterUserId(user.getUserId());
2156         Resource resource = new Resource(new ResourceMetadataDefinition(resourceMetadaData));
2157         resource.setComponentInstances(componentInstanceList);
2158         resource.setUniqueId(componentId);
2159         resource.setInterfaces(interfaceDefinitions);
2160
2161         user.setRole(Role.ADMIN.name());
2162
2163         when(userValidations.validateUserExists(Mockito.eq("userId")))
2164                 .thenReturn(user);
2165         when(toscaOperationFacade.getToscaFullElement(any()))
2166                 .thenReturn(Either.left(resource));
2167         when(artifactToscaOperation.getArtifactById(any(), any(), any(), any()))
2168                 .thenReturn(Either.left(artifactDefinition));
2169         when(artifactsResolver.findArtifactOnComponent(any(), any(ComponentTypeEnum.class), anyString()))
2170                 .thenReturn(artifactDefinition);
2171         when(graphLockOperation.lockComponent(eq(resource.getUniqueId()), any(NodeTypeEnum.class)))
2172                 .thenReturn(StorageOperationStatus.OK);
2173         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), anyString(), any(NodeTypeEnum.class), any(), anyBoolean()))
2174                 .thenReturn(Either.left(artifactDefinition));
2175         when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
2176                 .thenReturn(CassandraOperationStatus.OK);
2177         when(toscaOperationFacade.getToscaElement(anyString()))
2178                 .thenReturn(Either.left(resource));
2179         when(interfaceOperation.updateInterfaces(anyString(), anyList()))
2180                 .thenReturn(Either.left(interfaceDefinitionsList));
2181         when(artifactToscaOperation.getAllInstanceArtifacts(resource.getUniqueId(), componentId)).thenReturn(Either.left(artifactDefinitionMap));
2182         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(any(), any())).thenReturn(StorageOperationStatus.OK);
2183
2184         Either<ArtifactDefinition, Operation> result = artifactBL.handleArtifactRequest(componentId, user.getUserId(), ComponentTypeEnum.RESOURCE_INSTANCE
2185                 , operationInfo, artifactDefinition.getUniqueId(), artifactDefinition, requestMd5, "data", "iuuid",
2186                 null, componentId, "resources");
2187
2188         assertThat(result.isLeft()).isTrue();
2189         ArtifactDefinition leftValue = result.left().value();
2190         assertEquals(artifactDefinition.getArtifactName(), leftValue.getArtifactName());
2191     }
2192
2193     @Test
2194     public void testGenerateToscaArtifact() {
2195
2196         Resource resource = new Resource();
2197         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2198         resource.setUniqueId("resourceId");
2199
2200         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2201         artifactDefinition.setUniqueId("artifactId");
2202         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_CSAR.getType());
2203         User user = new User();
2204         boolean inCertificationRequest = false;
2205         boolean fetchTemplatesFromDB = false;
2206         boolean shouldLock = false;
2207         boolean inTransaction = false;
2208
2209         byte[] csar = "test.csar".getBytes();
2210
2211         when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2212                 .thenReturn(Either.left(csar));
2213         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(Component.class), anyString(), any(NodeTypeEnum.class), anyString(), anyBoolean()))
2214                 .thenReturn(Either.left(artifactDefinition));
2215         when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
2216                 .thenReturn(CassandraOperationStatus.OK);
2217
2218         Either<ArtifactDefinition, Operation> result
2219                 = artifactBL.generateAndSaveToscaArtifact(artifactDefinition, resource, user, inCertificationRequest,
2220                 shouldLock, inTransaction, fetchTemplatesFromDB);
2221
2222
2223         Assert.assertEquals(artifactDefinition.getUniqueId(), result.left().value().getUniqueId());
2224     }
2225
2226     @Test
2227     public void testHandleDownloadToscaModelRequest() {
2228         ArtifactsBusinessLogic testSubject = getTestSubject();
2229         byte[] generatedCsar = "test.csar".getBytes();
2230
2231         Resource resource = new Resource();
2232         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2233
2234         ArtifactDefinition csarArtifact = new ArtifactDefinition();
2235         csarArtifact.setArtifactName("csarArtifact");
2236         csarArtifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.getType());
2237         csarArtifact.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2238
2239         when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2240                 .thenReturn(Either.left(generatedCsar));
2241
2242         ImmutablePair<String, byte[]> result =
2243                 testSubject.handleDownloadToscaModelRequest(resource, csarArtifact);
2244
2245         assertEquals(csarArtifact.getArtifactName(), result.getKey());
2246     }
2247
2248     @Test
2249     public void testHandleDownloadRequestById_returnsSuccessful() {
2250         String componentId = "componentId";
2251         String artifactId = "artifactId";
2252         String parentId = "parentId";
2253
2254         DAOArtifactData daoArtifactData = new DAOArtifactData();
2255         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2256         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2257         Operation operation = new Operation();
2258         operation.setUniqueId("op1");
2259
2260         artifactDefinition.setArtifactName("test.csar");
2261         artifactDefinition.setArtifactType(ComponentTypeEnum.RESOURCE.name());
2262         artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
2263         artifactDefinition.setUniqueId(artifactId);
2264         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2265
2266         daoArtifactData.setDataAsArray("data".getBytes());
2267
2268         Resource resource = new Resource();
2269         resource.setUniqueId("resourceId");
2270         resource.setAbstract(false);
2271
2272         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2273         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
2274         interfaceDefinitionMap.put("interDef1", interfaceDefinition);
2275
2276         artifactDefinitionMap.put("artifact1", artifactDefinition);
2277
2278         resource.setDeploymentArtifacts(artifactDefinitionMap);
2279
2280         User user = new User();
2281         user.setUserId("userId");
2282
2283         when(userValidations.validateUserExists(eq(user.getUserId())))
2284                 .thenReturn(user);
2285         when(toscaOperationFacade.getToscaFullElement(eq(componentId)))
2286                 .thenReturn(Either.left(resource));
2287         when(artifactToscaOperation.getArtifactById(anyString(), anyString(), any(ComponentTypeEnum.class), anyString()))
2288                 .thenReturn(Either.left(artifactDefinition));
2289         when(artifactCassandraDao.getArtifact(any()))
2290                 .thenReturn(Either.left(daoArtifactData));
2291         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
2292
2293         ImmutablePair<String, byte[]> result =
2294                 artifactBL.handleDownloadRequestById(componentId, artifactId, user.getUserId(), ComponentTypeEnum.RESOURCE,
2295                         parentId, null);
2296         Assert.assertEquals(artifactDefinition.getArtifactName(), result.getKey());
2297     }
2298
2299     @Test
2300     public void testHandleDownloadRequestById_givenUserIdIsNull_thenReturnsError() {
2301         String componentId = "componentId";
2302         String userId = null;
2303         String artifactId = "artifactId";
2304
2305         try {
2306             ImmutablePair<String, byte[]> result =
2307                     artifactBL.handleDownloadRequestById(componentId, artifactId, userId, ComponentTypeEnum.RESOURCE, componentId
2308                             , null);
2309         } catch (ComponentException e) {
2310             assertEquals(e.getActionStatus(), ActionStatus.MISSING_INFORMATION);
2311             return;
2312         }
2313         fail();
2314     }
2315
2316     @Test
2317     public void testHandleGetArtifactByType_returnsSuccessful() {
2318         String parentId = "parentId";
2319         String componentId = "componentId";
2320         String artifactGroupType = ArtifactGroupTypeEnum.OTHER.name();
2321         String userId = "userId";
2322
2323         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2324         artifactDefinition.setArtifactName("test.csar");
2325
2326         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2327         artifactDefinitionMap.put("artifact1", artifactDefinition);
2328
2329         Service service = new Service();
2330         service.setUniqueId(componentId);
2331
2332         when(toscaOperationFacade.getToscaElement(eq(componentId), any(ComponentParametersView.class)))
2333                 .thenReturn(Either.left(service));
2334         when(graphLockOperation.lockComponent(eq(componentId), any(NodeTypeEnum.class)))
2335                 .thenReturn(StorageOperationStatus.OK);
2336         when(artifactToscaOperation.getArtifacts(any(), any(NodeTypeEnum.class), any(ArtifactGroupTypeEnum.class), any()))
2337                 .thenReturn(Either.left(artifactDefinitionMap));
2338
2339         Map<String, ArtifactDefinition> result =
2340                 artifactBL.handleGetArtifactsByType(ComponentTypeEnum.SERVICE.name(), parentId, ComponentTypeEnum.SERVICE,
2341                         componentId, artifactGroupType, userId);
2342         Assert.assertEquals(artifactDefinition.getArtifactName(), result.get("artifact1").getArtifactName());
2343     }
2344
2345     @Test
2346     public void testGetDeployment_returnsSuccessful() {
2347
2348         Resource resource = new Resource();
2349         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2350         ComponentInstance componentInstance = new ComponentInstance();
2351         NodeTypeEnum parentType = NodeTypeEnum.ResourceInstance;
2352         String ciId = "ciId";
2353
2354         artifactDefinition.setArtifactName("test.csar");
2355         componentInstance.setUniqueId(ciId);
2356         List<ComponentInstance> componentInstanceList = new ArrayList<>();
2357         componentInstanceList.add(componentInstance);
2358
2359         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2360         deploymentArtifacts.put("test.csar", artifactDefinition);
2361
2362         resource.setDeploymentArtifacts(deploymentArtifacts);
2363         resource.setComponentInstances(componentInstanceList);
2364         componentInstance.setDeploymentArtifacts(deploymentArtifacts);
2365
2366         List<ArtifactDefinition> result = artifactBL.getDeploymentArtifacts(resource, ciId);
2367         assertThat(result.size() == 1).isTrue();
2368         Assert.assertEquals(artifactDefinition.getArtifactName(), result.get(0).getArtifactName());
2369     }
2370
2371     @Test
2372     public void testHandleDelete_returnsSuccessful() {
2373
2374         String parentId = "parentId";
2375         String artifactId = "artifactId";
2376         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2377         Resource resource = new Resource();
2378         User user = new User();
2379
2380         artifactDefinition.setArtifactName("test.csar");
2381         artifactDefinition.setUniqueId(artifactId);
2382         artifactDefinition.setEsId("esId");
2383
2384         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
2385
2386         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2387         deploymentArtifacts.put(artifactId, artifactDefinition);
2388
2389         resource.setUniqueId(parentId);
2390         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2391         resource.setDeploymentArtifacts(deploymentArtifacts);
2392
2393         when(graphLockOperation.lockComponent(eq(parentId), any(NodeTypeEnum.class)))
2394                 .thenReturn(StorageOperationStatus.OK);
2395         when(toscaOperationFacade.getToscaElement(eq(parentId)))
2396                 .thenReturn(Either.left(resource));
2397         when(artifactToscaOperation.isCloneNeeded(any(), any(ArtifactDefinition.class), any(NodeTypeEnum.class)))
2398                 .thenReturn(Either.left(Boolean.FALSE));
2399         when(artifactToscaOperation.removeArtifactOnGraph(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class), anyBoolean()))
2400                 .thenReturn(Either.left(artifactDataDefinition));
2401         when(artifactCassandraDao.deleteArtifact(any()))
2402                 .thenReturn(CassandraOperationStatus.OK);
2403
2404         Either<ArtifactDefinition, ResponseFormat> result = artifactBL.handleDelete(
2405             parentId, artifactId, user, resource, true, false);
2406         Assert.assertEquals(artifactDefinition.getArtifactName(), result.left().value().getArtifactName());
2407     }
2408
2409     @Test
2410     public void testDownloadRsrcArtifactByNames_givenServiceNameNull_thenReturnsError() {
2411         String serviceName = null;
2412         String serviceVersion = "2.0";
2413         String resourceName = "resource";
2414         String resourceVersion = "1.0";
2415         String artifactName = "artifactName";
2416
2417         try{
2418             artifactBL.downloadRsrcArtifactByNames(serviceName, serviceVersion, resourceName, resourceVersion, artifactName);
2419         } catch(ComponentException e) {
2420             assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
2421             return;
2422         }
2423         fail();
2424
2425     }
2426
2427     @Test
2428     public void testDownloadRsrcArtifactByNames_returnsSuccessful() {
2429
2430         String serviceName = "service1";
2431         String resourceName = "resource1";
2432         String artifactName = "artifact1";
2433         String version = "1.0";
2434
2435         Resource resource = new Resource();
2436         resource.setName(resourceName);
2437         resource.setVersion(version);
2438
2439         Service service = new Service();
2440         service.setVersion(version);
2441         service.setName(serviceName);
2442
2443         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2444         artifactDefinition.setEsId("esId");
2445
2446         DAOArtifactData esArtifactData = new DAOArtifactData();
2447         esArtifactData.setDataAsArray("test".getBytes());
2448
2449         artifactDefinition.setArtifactName(artifactName);
2450         List<Service> serviceList = new ArrayList<>();
2451         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2452         artifacts.put(artifactName, artifactDefinition);
2453
2454         serviceList.add(service);
2455         resource.setDeploymentArtifacts(artifacts);
2456
2457         when(toscaOperationFacade.getComponentByNameAndVersion(eq(ComponentTypeEnum.RESOURCE), eq(resourceName), eq(version), eq(JsonParseFlagEnum.ParseMetadata)))
2458                 .thenReturn(Either.left(resource));
2459         doReturn(Either.left(serviceList)).when(toscaOperationFacade).getBySystemName(eq(ComponentTypeEnum.SERVICE), eq(serviceName));
2460         when(artifactCassandraDao.getArtifact(any()))
2461                 .thenReturn(Either.left(esArtifactData));
2462
2463         byte[] result = artifactBL.downloadRsrcArtifactByNames(serviceName, version, resourceName, version, artifactName);
2464         Assert.assertEquals(esArtifactData.getDataAsArray(), result);
2465     }
2466
2467     private ArtifactsBusinessLogic getTestSubject() {
2468         final ArtifactsBusinessLogic artifactsBusinessLogic = new ArtifactsBusinessLogic(artifactCassandraDao,
2469             toscaExportHandler, csarUtils, lifecycleBusinessLogic,
2470             userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation,
2471             groupTypeOperation,
2472             interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
2473         artifactsBusinessLogic.setComponentsUtils(componentsUtils);
2474         return artifactsBusinessLogic;
2475     }
2476 }