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