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