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