catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ArtifactBusinessLogicTest.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  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import com.fasterxml.jackson.annotation.JsonInclude;
  24 import com.fasterxml.jackson.databind.DeserializationFeature;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import com.fasterxml.jackson.databind.SerializationFeature;
  27 import com.google.gson.Gson;
  28 import com.google.gson.GsonBuilder;
  29 import com.google.gson.JsonElement;
  30 import fj.data.Either;
  31 import org.apache.commons.codec.binary.Base64;
  32 import org.apache.commons.lang3.tuple.ImmutablePair;
  33 import org.apache.http.HttpStatus;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.junit.runner.RunWith;
  37 import org.mockito.InjectMocks;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.mockito.junit.MockitoJUnitRunner;
  41 import org.openecomp.sdc.be.components.ArtifactsResolver;
  42 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  43 import org.openecomp.sdc.be.components.utils.ArtifactBuilder;
  44 import org.openecomp.sdc.be.components.utils.ObjectGenerator;
  45 import org.openecomp.sdc.be.components.validation.UserValidations;
  46 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
  47 import org.openecomp.sdc.be.config.ConfigurationManager;
  48 import org.openecomp.sdc.be.config.validation.DeploymentArtifactHeatConfiguration;
  49 import org.openecomp.sdc.be.dao.api.ActionStatus;
  50 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  51 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  52 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  53 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  54 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  55 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  57 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  58 import org.openecomp.sdc.be.impl.ComponentsUtils;
  59 import org.openecomp.sdc.be.model.ArtifactDefinition;
  60 import org.openecomp.sdc.be.model.ArtifactType;
  61 import org.openecomp.sdc.be.model.Component;
  62 import org.openecomp.sdc.be.model.ComponentInstance;
  63 import org.openecomp.sdc.be.model.ComponentParametersView;
  64 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  65 import org.openecomp.sdc.be.model.InterfaceDefinition;
  66 import org.openecomp.sdc.be.model.Operation;
  67 import org.openecomp.sdc.be.model.Resource;
  68 import org.openecomp.sdc.be.model.Service;
  69 import org.openecomp.sdc.be.model.User;
  70 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
  71 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  72 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  73 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  74 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  75 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  76 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  77 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  78 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
  79 import org.openecomp.sdc.be.resources.data.ESArtifactData;
  80 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  81 import org.openecomp.sdc.be.servlets.RepresentationUtils;
  82 import org.openecomp.sdc.be.tosca.CsarUtils;
  83 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
  84 import org.openecomp.sdc.be.user.UserBusinessLogic;
  85 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  86 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  87 import org.openecomp.sdc.common.api.ConfigurationSource;
  88 import org.openecomp.sdc.common.datastructure.Wrapper;
  89 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  90 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  91 import org.openecomp.sdc.common.util.GeneralUtility;
  92 import org.openecomp.sdc.exception.ResponseFormat;
  93
  94 import java.io.IOException;
  95 import java.util.*;
  96
  97 import static junit.framework.TestCase.assertEquals;
  98 import static junit.framework.TestCase.assertFalse;
  99 import static junit.framework.TestCase.assertNull;
 100 import static junit.framework.TestCase.assertTrue;
 101 import static org.assertj.core.api.Java6Assertions.assertThat;
 102 import static org.junit.Assert.assertArrayEquals;
 103 import static org.mockito.ArgumentMatchers.any;
 104 import static org.mockito.ArgumentMatchers.anyBoolean;
 105 import static org.mockito.ArgumentMatchers.anyString;
 106 import static org.mockito.ArgumentMatchers.eq;
 107 import static org.mockito.Mockito.*;
 108 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
 109 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
 110
 111 @RunWith(MockitoJUnitRunner.class)
 112 public class ArtifactBusinessLogicTest extends BaseBusinessLogicMock{
 113
 114     public static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN", System.currentTimeMillis());
 115     private final static String RESOURCE_INSTANCE_NAME = "Service-111";
 116     private final static String INSTANCE_ID = "S-123-444-ghghghg";
 117
 118     private final static String ARTIFACT_NAME = "service-Myservice-template.yml";
 119     private final static String ARTIFACT_LABEL = "assettoscatemplate";
 120     private final static String ES_ARTIFACT_ID = "123123dfgdfgd0";
 121     private final static byte[] PAYLOAD = "some payload".getBytes();
 122
 123     static ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
 124     static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 125
 126     @InjectMocks
 127     private ArtifactsBusinessLogic artifactBL;
 128     @Mock
 129     private ArtifactOperation artifactOperation;
 130     @Mock
 131     public ComponentsUtils componentsUtils;
 132     @Mock
 133     private IInterfaceLifecycleOperation lifecycleOperation;
 134     @Mock
 135     private IUserAdminOperation userOperation;
 136     @Mock
 137     private IElementOperation elementOperation;
 138     @Mock
 139     private ArtifactCassandraDao artifactCassandraDao;
 140     @Mock
 141     public ToscaOperationFacade toscaOperationFacade;
 142     @Mock
 143     private UserBusinessLogic userBusinessLogic;
 144     @Mock
 145     private NodeTemplateOperation nodeTemplateOperation;
 146     @Mock
 147     private IGraphLockOperation graphLockOperation;
 148     @Mock
 149     JanusGraphDao janusGraphDao;
 150     @Mock
 151     private IInterfaceLifecycleOperation interfaceLifecycleOperation;
 152     @Mock
 153     private ResponseFormat responseFormat;
 154     @Mock
 155     private User user;
 156     @Mock
 157     private ToscaExportHandler toscaExportHandler;
 158     @Mock
 159     private CsarUtils csarUtils;
 160     @Mock
 161     private LifecycleBusinessLogic lifecycleBusinessLogic;
 162     @Mock
 163     private ArtifactsResolver artifactsResolver;
 164
 165     public static final Resource resource = Mockito.mock(Resource.class);
 166     private Gson gson = new GsonBuilder().setPrettyPrinting().create();
 167
 168
 169     private static List<ArtifactType> getAllTypes() {
 170         List<ArtifactType> artifactTypes = new ArrayList<>();
 171         List<String> artifactTypesList = ConfigurationManager.getConfigurationManager().getConfiguration().getArtifactTypes();
 172         for (String artifactType : artifactTypesList) {
 173             ArtifactType artifactT = new ArtifactType();
 174             artifactT.setName(artifactType);
 175             artifactTypes.add(artifactT);
 176         }
 177         return artifactTypes;
 178     }
 179
 180     @Before
 181     public void initMocks() {
 182 //        MockitoAnnotations.initMocks(this);
 183         Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either.right(StorageOperationStatus.NOT_FOUND);
 184
 185         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either.right(StorageOperationStatus.NOT_FOUND);
 186         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either.right(StorageOperationStatus.NOT_FOUND);
 187         Either<User, ActionStatus> getUserResult = Either.left(USER);
 188
 189         Either<List<ArtifactType>, ActionStatus> getType = Either.left(getAllTypes());
 190
 191         when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
 192     }
 193
 194     @Test
 195     public void testValidJson() {
 196         ArtifactDefinition ad = createArtifactDef("artifact1.yml", ArtifactGroupTypeEnum.DEPLOYMENT);
 197
 198         String jsonArtifact  = "";
 199
 200         ObjectMapper mapper = new ObjectMapper();
 201         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 202         mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 203         mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 204
 205         try {
 206             jsonArtifact = mapper.writeValueAsString(ad);
 207         } catch (IOException e) {
 208             // TODO Auto-generated catch block
 209             e.printStackTrace();
 210         }
 211
 212         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact, ArtifactDefinition.class);
 213         assertThat(afterConvert).isEqualTo(ad);
 214     }
 215
 216     private ArtifactDefinition createArtifactDef(String artifactName, ArtifactGroupTypeEnum groupTypeEnum) {
 217         ArtifactDefinition ad = new ArtifactDefinition();
 218         ad.setArtifactName(artifactName);
 219         ad.setArtifactLabel("label1");
 220         ad.setDescription("description");
 221         ad.setArtifactType(ArtifactTypeEnum.HEAT.getType());
 222         ad.setArtifactGroupType(groupTypeEnum);
 223         ad.setCreationDate(System.currentTimeMillis());
 224         ad.setMandatory(false);
 225         ad.setTimeout(15);
 226         return ad;
 227     }
 228
 229     @Test
 230     public void testInvalidStringGroupType() {
 231         ArtifactDefinition ad = new ArtifactDefinition();
 232         ad.setArtifactName("artifact1");
 233         ad.setCreationDate(System.currentTimeMillis());
 234         ad.setMandatory(false);
 235         ad.setTimeout(15);
 236
 237         JsonElement jsonArtifact = gson.toJsonTree(ad);
 238         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
 239
 240         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(), ArtifactDefinition.class);
 241         assertThat(afterConvert).isNull();
 242     }
 243
 244     @Test
 245     public void testInvalidNumberGroupType() {
 246         ArtifactDefinition ad = new ArtifactDefinition();
 247         ad.setArtifactName("artifact1");
 248         ad.setCreationDate(System.currentTimeMillis());
 249         ad.setMandatory(false);
 250         ad.setTimeout(15);
 251
 252         JsonElement jsonArtifact = gson.toJsonTree(ad);
 253         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
 254
 255         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(), ArtifactDefinition.class);
 256         assertThat(afterConvert).isNull();
 257     }
 258
 259     @Test
 260     public void testInvalidGroupTypeWithSpace() {
 261         ArtifactDefinition ad = new ArtifactDefinition();
 262         ad.setArtifactName("artifact1");
 263         ad.setCreationDate(System.currentTimeMillis());
 264         ad.setMandatory(false);
 265         ad.setTimeout(15);
 266
 267         JsonElement jsonArtifact = gson.toJsonTree(ad);
 268         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 269
 270         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(), ArtifactDefinition.class);
 271         assertThat(afterConvert).isNull();
 272     }
 273
 274     @Test
 275     public void testInvalidTimeoutWithSpace() {
 276         ArtifactDefinition ad = new ArtifactDefinition();
 277         ad.setArtifactName("artifact1");
 278         ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 279         ad.setCreationDate(System.currentTimeMillis());
 280         ad.setMandatory(false);
 281
 282         JsonElement jsonArtifact = gson.toJsonTree(ad);
 283         jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
 284
 285         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(), ArtifactDefinition.class);
 286         assertThat(afterConvert).isNull();
 287     }
 288
 289     @Test
 290     public void validateArtifactNameUniqueness_Unique() {
 291
 292         ArtifactDefinition artifactInfo = createArtifactDef("artifactName3.yml", ArtifactGroupTypeEnum.DEPLOYMENT);
 293         ArtifactDefinition informationArtifactDefinition1 = createArtifactDef("artifactName1.yml",
 294                 ArtifactGroupTypeEnum.INFORMATIONAL);
 295         ArtifactDefinition deploymentArtifactDefinition2 = createArtifactDef("artifactName2.yml",
 296                 ArtifactGroupTypeEnum.DEPLOYMENT);
 297
 298         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
 299         artifactDefinitionMap.put("informationArtifact", informationArtifactDefinition1);
 300         artifactDefinitionMap.put("DeploymentArtifact", deploymentArtifactDefinition2);
 301
 302         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = Either.left(artifactDefinitionMap);
 303         when(artifactToscaOperation.getAllInstanceArtifacts(anyString(), anyString())).thenReturn(artifacts);
 304
 305         Resource parent = new Resource();
 306         parent.setUniqueId("uniqueId");
 307
 308         assertThat(artifactBL.validateArtifactNameUniqueness("componentId", parent,
 309                 artifactInfo , ComponentTypeEnum.RESOURCE_INSTANCE)).isTrue();
 310     }
 311
 312     @Test
 313     public void validateArtifactNameUniqueness_nonUniqueResourceInterfaces() {
 314
 315         ArtifactDefinition artifactInfo = createArtifactDef("artifactName3.yml", ArtifactGroupTypeEnum.DEPLOYMENT);
 316         ArtifactDefinition informationArtifactDefinition1 = createArtifactDef("artifactName1.yml",
 317                 ArtifactGroupTypeEnum.INFORMATIONAL);
 318         ArtifactDefinition deploymentArtifactDefinition2 = createArtifactDef("artifactName2.yml",
 319                 ArtifactGroupTypeEnum.DEPLOYMENT);
 320
 321         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
 322         artifactDefinitionMap.put("informationArtifact", informationArtifactDefinition1);
 323         artifactDefinitionMap.put("DeploymentArtifact", deploymentArtifactDefinition2);
 324
 325         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = Either.left(artifactDefinitionMap);
 326         when(artifactToscaOperation.getArtifacts(anyString())).thenReturn(artifacts);
 327
 328
 329         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource =
 330                 Either.left(createInterfaceDefinitionMap("artifactName3.yml"));
 331         when(interfaceLifecycleOperation.getAllInterfacesOfResource("componentId", true, true))
 332                 .thenReturn(allInterfacesOfResource);
 333
 334         Resource parent = new Resource();
 335         parent.setUniqueId("uniqueId");
 336
 337         assertThat(artifactBL.validateArtifactNameUniqueness("componentId", parent,
 338                 artifactInfo, ComponentTypeEnum.RESOURCE)).isFalse();
 339     }
 340
 341     @Test
 342     public void validateArtifactNameUniqueness_UniqueInterface() {
 343
 344         ArtifactDefinition artifactInfo = createArtifactDef("artifactName2.yml", ArtifactGroupTypeEnum.DEPLOYMENT);
 345         artifactInfo.setArtifactLabel("uniqueLabel");
 346         ArtifactDefinition informationArtifactDefinition1 = createArtifactDef("artifactName1.yml",
 347                 ArtifactGroupTypeEnum.INFORMATIONAL);
 348         ArtifactDefinition deploymentArtifactDefinition2 = createArtifactDef("artifactName2.yml",
 349                 ArtifactGroupTypeEnum.DEPLOYMENT);
 350
 351         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
 352         artifactDefinitionMap.put(informationArtifactDefinition1.getArtifactLabel(), informationArtifactDefinition1);
 353         artifactDefinitionMap.put(deploymentArtifactDefinition2.getArtifactLabel(), deploymentArtifactDefinition2);
 354
 355         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = Either.left(artifactDefinitionMap);
 356         when(artifactToscaOperation.getArtifacts(anyString())).thenReturn(artifacts);
 357
 358
 359         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource =
 360                 Either.left(createInterfaceDefinitionMap("artifactName3.yml"));
 361
 362         Resource parent = new Resource();
 363         parent.setUniqueId("uniqueId");
 364
 365         assertThat(artifactBL.validateArtifactNameUniqueness("componentId", parent,
 366                 artifactInfo, ComponentTypeEnum.RESOURCE)).isFalse();
 367     }
 368
 369     @Test
 370     public void validateArtifactNameUniqueness_updateName() {
 371         //artifacts with the same name have the same label
 372         ArtifactDefinition artifactInfo = createArtifactDef("artifactName2.yml", ArtifactGroupTypeEnum.DEPLOYMENT);
 373         ArtifactDefinition informationArtifactDefinition1 = createArtifactDef("artifactName1.yml",
 374                 ArtifactGroupTypeEnum.INFORMATIONAL);
 375         informationArtifactDefinition1.setArtifactLabel("label2");
 376         ArtifactDefinition deploymentArtifactDefinition2 = createArtifactDef("artifactName2.yml",
 377                 ArtifactGroupTypeEnum.DEPLOYMENT);
 378
 379         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
 380         artifactDefinitionMap.put(artifactInfo.getArtifactLabel(), artifactInfo);
 381         artifactDefinitionMap.put(informationArtifactDefinition1.getArtifactLabel(), informationArtifactDefinition1);
 382         artifactDefinitionMap.put(deploymentArtifactDefinition2.getArtifactLabel(), deploymentArtifactDefinition2);
 383
 384         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = Either.left(artifactDefinitionMap);
 385         when(artifactToscaOperation.getAllInstanceArtifacts(anyString(), anyString())).thenReturn(artifacts);
 386
 387         Resource parent = new Resource();
 388         parent.setUniqueId("uniqueId");
 389
 390         assertThat(artifactBL.validateArtifactNameUniqueness("componentId", parent,
 391                 artifactInfo, ComponentTypeEnum.RESOURCE_INSTANCE)).isTrue();
 392     }
 393
 394     @Test
 395     public void validateArtifactNameUniqueness_UniqueInGroupType() {
 396
 397         ArtifactDefinition artifactInfo = createArtifactDef("artifactName2.yml", ArtifactGroupTypeEnum.INFORMATIONAL);
 398         ArtifactDefinition informationArtifactDefinition1 = createArtifactDef("artifactName1.yml",
 399                 ArtifactGroupTypeEnum.INFORMATIONAL);
 400         ArtifactDefinition deploymentArtifactDefinition2 = createArtifactDef("artifactName2.yml",
 401                 ArtifactGroupTypeEnum.DEPLOYMENT);
 402
 403         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
 404         artifactDefinitionMap.put("informationArtifact", informationArtifactDefinition1);
 405         artifactDefinitionMap.put("DeploymentArtifact", deploymentArtifactDefinition2);
 406
 407         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = Either.left(artifactDefinitionMap);
 408         when(artifactToscaOperation.getAllInstanceArtifacts(anyString(), anyString())).thenReturn(artifacts);
 409
 410         Resource parent = new Resource();
 411         parent.setUniqueId("uniqueId");
 412
 413         assertThat(artifactBL.validateArtifactNameUniqueness("componentId", parent, artifactInfo,
 414                 ComponentTypeEnum.RESOURCE_INSTANCE)).isTrue();
 415     }
 416
 417     @Test
 418     public void validateArtifactNameUniqueness_NonUnique() {
 419
 420         ArtifactDefinition artifactInfo = createArtifactDef("artifactName1.yml", ArtifactGroupTypeEnum.INFORMATIONAL);
 421         artifactInfo.setArtifactLabel("artifactLabel");
 422         ArtifactDefinition informationArtifactDefinition1 = createArtifactDef("artifactName1.yml",
 423                 ArtifactGroupTypeEnum.INFORMATIONAL);
 424         ArtifactDefinition deploymentArtifactDefinition2 = createArtifactDef("artifactName2.yml",
 425                 ArtifactGroupTypeEnum.DEPLOYMENT);
 426
 427         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
 428         artifactDefinitionMap.put("informationArtifact", informationArtifactDefinition1);
 429         artifactDefinitionMap.put("DeploymentArtifact", deploymentArtifactDefinition2);
 430
 431         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = Either.left(artifactDefinitionMap);
 432         when(artifactToscaOperation.getAllInstanceArtifacts(anyString(), anyString())).thenReturn(artifacts);
 433
 434         Resource parent = new Resource();
 435         parent.setUniqueId("uniqueId");
 436
 437         assertThat(artifactBL.validateArtifactNameUniqueness("componentId", parent, artifactInfo,
 438                 ComponentTypeEnum.RESOURCE_INSTANCE)).isFalse();
 439     }
 440
 441
 442     private Map<String, InterfaceDefinition> createInterfaceDefinitionMap(String artifactName) {
 443
 444         InterfaceDefinition id1 = new InterfaceDefinition();
 445         Map<String, Operation> operationMap = new HashMap<>();
 446         Operation operation1 = new Operation();
 447         ArtifactDataDefinition dataImplementation = new ArtifactDataDefinition();
 448         dataImplementation.setArtifactName(artifactName);
 449         operation1.setImplementation(dataImplementation);
 450         operationMap.put("operation1", operation1);
 451         id1.setOperationsMap(operationMap);
 452         Map<String, InterfaceDefinition> interfaceDefMap = new HashMap<>();
 453         interfaceDefMap.put("id1",id1);
 454         return interfaceDefMap;
 455     }
 456
 457     @Test
 458     public void testValidMibAritactsConfiguration() {
 459         Map<String, ArtifactTypeConfig> componentDeploymentArtifacts =
 460                 ConfigurationManager.getConfigurationManager().getConfiguration().getResourceDeploymentArtifacts();
 461         Map<String, ArtifactTypeConfig> componentInstanceDeploymentArtifacts =
 462                 ConfigurationManager.getConfigurationManager().getConfiguration().getResourceInstanceDeploymentArtifacts();
 463         assertThat(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType())).isTrue();
 464         assertThat(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType())).isTrue();
 465         assertThat(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType())).isTrue();
 466         assertThat(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType())).isTrue();
 467     }
 468
 469     @Test
 470     public void testDownloadServiceArtifactByNames() {
 471         Service service = new Service();
 472         String serviceName = "myService";
 473         String serviceVersion = "1.0";
 474         String serviceId = "serviceId";
 475         service.setName(serviceName);
 476         service.setVersion(serviceVersion);
 477         service.setUniqueId(serviceId);
 478
 479         String artifactName = "service-Myservice-template.yml";
 480         String artifactLabel = "assettoscatemplate";
 481         String esArtifactId = "123123dfgdfgd0";
 482         byte[] payload = "some payload".getBytes();
 483         ArtifactDefinition toscaTemplateArtifact = new ArtifactDefinition();
 484         toscaTemplateArtifact.setArtifactName(artifactName);
 485         toscaTemplateArtifact.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 486         toscaTemplateArtifact.setArtifactLabel(artifactLabel);
 487         toscaTemplateArtifact.setEsId(esArtifactId);
 488         toscaTemplateArtifact.setPayload(payload);
 489
 490         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 491         toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
 492         service.setToscaArtifacts(toscaArtifacts);
 493
 494         ESArtifactData esArtifactData =new ESArtifactData(esArtifactId);
 495         esArtifactData.setDataAsArray(payload);
 496         Either<ESArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(esArtifactData);
 497         when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
 498         List<org.openecomp.sdc.be.model.Component> serviceList = new ArrayList<>();
 499         serviceList.add(service);
 500         Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> getServiceRes = Either.left(serviceList);
 501         when(toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName)).thenReturn(getServiceRes);
 502         Either<byte[], ResponseFormat> downloadServiceArtifactByNamesRes =
 503                 artifactBL.downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
 504         assertThat(downloadServiceArtifactByNamesRes.isLeft()).isTrue();
 505         assertThat(downloadServiceArtifactByNamesRes.left().value() !=null &&
 506                 downloadServiceArtifactByNamesRes.left().value().length == payload.length).isTrue();
 507     }
 508
 509     @Test
 510     public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
 511         ArtifactDefinition heatArtifact = new ArtifactBuilder()
 512                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
 513                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2"))
 514                 .build();
 515
 516         Resource component = new Resource();
 517         when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(Either.left(USER));
 518         when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class), eq(component.getUniqueId()), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 519                 .thenReturn(Either.left(new ArtifactDefinition()));
 520         Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component, Collections.emptyMap());
 521         assertThat(heatEnvPlaceHolder.isLeft()).isTrue();
 522         assertThat(heatEnvPlaceHolder.left().value().getListHeatParameters()).isNull();
 523     }
 524
 525     @Test
 526     public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal() throws Exception {
 527         HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
 528         HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
 529         HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
 530         ArtifactDefinition heatArtifact = new ArtifactBuilder()
 531                 .addHeatParam(heatParam1)
 532                 .addHeatParam(heatParam2)
 533                 .addHeatParam(heatParam3)
 534                 .build();
 535
 536         Resource component = new Resource();
 537
 538         when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(Either.left(USER));
 539
 540         Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component, Collections.emptyMap());
 541
 542         assertThat(heatEnvPlaceHolder.isLeft()).isTrue();
 543         ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder.left().value();
 544         List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
 545         assertThat(listHeatParameters.size()).isEqualTo(3);
 546         verifyHeatParam(listHeatParameters.get(0), heatParam1);
 547         verifyHeatParam(listHeatParameters.get(1), heatParam2);
 548         verifyHeatParam(listHeatParameters.get(2), heatParam3);
 549     }
 550
 551     @Test
 552     public void buildArtifactPayloadWhenShouldLockAndInTransaction() {
 553         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 554         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 555         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 556         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 557         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 558         artifactDefinition.setPayload(PAYLOAD);
 559         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 560
 561         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 562         //TODO Remove if passes
 563         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class)
 564                 , any(String.class))).thenReturn(Either.left(artifactDefinition));
 565         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 566         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 567         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD), ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME,
 568                 USER, INSTANCE_ID, true, true);
 569     }
 570
 571     private ArtifactsBusinessLogic getArtifactsBusinessLogic() {
 572         ArtifactsBusinessLogic artifactsBusinessLogic = new ArtifactsBusinessLogic(artifactCassandraDao,
 573             toscaExportHandler, csarUtils, lifecycleBusinessLogic,
 574             userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation,
 575             groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
 576         artifactsBusinessLogic.setGraphLockOperation(graphLockOperation);
 577         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 578         return artifactsBusinessLogic;
 579     }
 580
 581     @Test
 582     public void buildArtifactPayloadWhenShouldLockAndNotInTransaction() {
 583         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 584         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 585         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 586         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 587         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 588         artifactDefinition.setPayload(PAYLOAD);
 589         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 590
 591         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 592         //TODO Remove if passes
 593         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class)
 594                 , any(String.class))).thenReturn(Either.left(artifactDefinition));
 595         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 596         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 597         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD), ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME,
 598                 USER, INSTANCE_ID, true, false);
 599         verify(janusGraphDao, times(1)).commit();
 600     }
 601
 602     @Test
 603     public void testDeleteComponent_ArtifactNotFound(){
 604         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result;
 605         Resource resource = new Resource();
 606         String uniqueId = "uniqueId";
 607         resource.setUniqueId(uniqueId);
 608         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 609         ArtifactDefinition artifact = new ArtifactDefinition();
 610         artifact.setArtifactName("artifactName");
 611         artifact.setEsId("esId");
 612         artifact.setArtifactUUID("artifactUUID");
 613         artifact.setArtifactType("YANG");
 614         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 615         artifact.setDescription("description");
 616         artifact.setArtifactLabel("artifactLabel");
 617         toscaArtifacts.put("artifactId", artifact);
 618         resource.setArtifacts(toscaArtifacts);
 619         resource.setToscaArtifacts(toscaArtifacts);
 620         when(graphLockOperation.lockComponent(uniqueId, NodeTypeEnum.Resource))
 621                 .thenReturn(StorageOperationStatus.OK);
 622         when(graphLockOperation.unlockComponent(uniqueId, NodeTypeEnum.Resource))
 623                 .thenReturn(StorageOperationStatus.OK);
 624         when(toscaOperationFacade.getToscaElement(uniqueId)).thenReturn(Either.left(resource));
 625         when(componentsUtils.getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NOT_FOUND, "artifactId")).
 626                 thenReturn(responseFormat);
 627         result = artifactBL.handleDelete("parentId", "artifactId", user, AuditingActionEnum.ARTIFACT_DELETE,
 628                 ComponentTypeEnum.RESOURCE, resource,
 629                 true, false);
 630         assertThat(result.isRight());
 631     }
 632
 633     @Test
 634     public void validateHandleArtifactRequestReturnsProperResponseMessage() {
 635         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 636
 637         final String componentId = "testComponent";
 638         final String userId = "testUser";
 639         final String artifactId = "testArtifact";
 640         final String origMd5 = "testOrigMd5";
 641         final String originData = "testOriginData";
 642         final String interfaceUuid = "testInterfaceUuid";
 643         final String operationUuid = "testOperationUuid";
 644         final String parentId = "testParentId";
 645         final String containerComponentType = "services";
 646         User testUser = new User();
 647         ComponentTypeEnum componentType = ComponentTypeEnum.SERVICE_INSTANCE;
 648
 649         ArtifactsBusinessLogic.ArtifactOperationInfo operation = Mockito.mock(ArtifactsBusinessLogic.ArtifactOperationInfo.class);
 650         when(operation.getArtifactOperationEnum()).thenReturn(ArtifactsBusinessLogic.ArtifactOperationEnum.DOWNLOAD);
 651
 652         UserValidations testUserValidation = Mockito.mock(UserValidations.class);
 653         when(testUserValidation.validateUserExists(eq(userId),any(String.class),anyBoolean())).thenReturn(testUser);
 654
 655         ResponseFormat responseFormat = Mockito.mock(ResponseFormat.class);
 656
 657         ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
 658         when(componentsUtils.getResponseFormat(any(ActionStatus.class),eq(componentId)) ).thenReturn(responseFormat);
 659
 660         ArtifactDefinition artifactInfo = new ArtifactDefinition();
 661
 662         Either<Component, StorageOperationStatus> storageStatus = Either.right(StorageOperationStatus.OK);//.RightProjection<Component, StorageOperationStatus>() ;
 663         when(toscaOperationFacade.getToscaFullElement(eq(componentId))).thenReturn(storageStatus);
 664
 665         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 666         testArtifactsBusinessLogic.setUserValidations(testUserValidation);
 667         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> response = testArtifactsBusinessLogic.handleArtifactRequest(
 668                 componentId, userId,  componentType,  operation,
 669                 artifactId,  artifactInfo, origMd5, originData,
 670                 interfaceUuid, operationUuid, parentId, containerComponentType);
 671
 672         assertTrue(response.isRight());
 673         assertEquals(response.right().value(), responseFormat);
 674     }
 675
 676
 677     @Test
 678     public void validateHandleArtifactRequestWithNoUserReturnsMissingInformationResponseMessage() {
 679         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 680
 681         final String componentId = "testComponent";
 682         final String artifactId = "testArtifact";
 683         final String origMd5 = "testOrigMd5";
 684         final String originData = "testOriginData";
 685         final String interfaceUuid = "testInterfaceUuid";
 686         final String operationUuid = "testOperationUuid";
 687         final String parentId = "testParentId";
 688         final String containerComponentType = "services";
 689         ArtifactDefinition artifactInfo = new ArtifactDefinition();
 690         ComponentTypeEnum componentType = ComponentTypeEnum.SERVICE_INSTANCE;
 691
 692         ArtifactsBusinessLogic.ArtifactOperationInfo operation =
 693                 Mockito.mock(ArtifactsBusinessLogic.ArtifactOperationInfo.class);
 694         when(operation.getArtifactOperationEnum()).thenReturn(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 695
 696         ResponseFormat responseFormat = Mockito.mock(ResponseFormat.class);
 697
 698         when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_INFORMATION)) ).thenReturn(responseFormat);
 699
 700         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 701         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> response =
 702                 testArtifactsBusinessLogic.handleArtifactRequest(
 703                     componentId, null,  componentType,  operation,
 704                     artifactId,  artifactInfo, origMd5, originData,
 705                     interfaceUuid, operationUuid, parentId, containerComponentType
 706                 );
 707
 708         assertTrue(response.isRight());
 709         assertEquals(response.right().value(), responseFormat);
 710     }
 711
 712     @Test
 713     public void validateValidateAndHandleArtifactWillCallAuditResourceWithProperParameters() {
 714         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 715
 716         final String componentUniqueId = "testComponentId";
 717         final ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 718         final ArtifactsBusinessLogic.ArtifactOperationInfo operation = Mockito.mock(ArtifactsBusinessLogic.ArtifactOperationInfo.class);
 719         final String artifactUniqueId = "testArtifactId";
 720         final String artifactName = "testArtifact";
 721         final String artifactType = "testData";
 722         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 723         artifactDefinition.setArtifactType("testArtifact");
 724         final String origMd5 = GeneralUtility.calculateMD5Base64EncodedByString(artifactType);
 725         final String interfaceUuid = "testInterfaceUUID";
 726         final String operationName = "testOperation";
 727         final User user = new User();
 728         final Resource component = Mockito.mock(Resource.class);
 729         when(component.getName()).thenReturn(artifactName);
 730         final boolean shouldLock = false;
 731         final boolean inTransaction = false;
 732         final boolean needUpdateGroup = false;
 733
 734         when(operation.getArtifactOperationEnum()).thenReturn(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 735
 736         when(componentsUtils.isExternalApiEvent(AuditingActionEnum.ARTIFACT_UPLOAD)).thenReturn(false);
 737
 738         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 739         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> response =
 740                 testArtifactsBusinessLogic.validateAndHandleArtifact(
 741                     componentUniqueId,  componentType, operation,
 742                     artifactUniqueId, artifactDefinition, origMd5,
 743                     artifactType, interfaceUuid, operationName,
 744                     user, component, shouldLock, inTransaction, needUpdateGroup
 745                 );
 746
 747         assertTrue(response.isRight());
 748         assertNull(response.right().value());
 749         verify(componentsUtils).auditResource(
 750                 eq(null), eq(user), eq(component),
 751                 eq(artifactName), eq(AuditingActionEnum.ARTIFACT_UPLOAD), any(ResourceVersionInfo.class),
 752                 eq(null), eq(null));
 753     }
 754
 755     @Test
 756     public void validateGenerateAndSaveToscaArtifactStoresProperArtifact() {
 757         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 758
 759         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 760
 761         final ArtifactDefinition artifactDefinition = Mockito.mock(ArtifactDefinition.class);
 762         when(artifactDefinition.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_CSAR.getType());
 763         final Component component = Mockito.mock(Component.class);
 764         final User user = new User();
 765         final boolean isInCertificationRequest = false;
 766         final boolean shouldLock = false;
 767         final boolean inTransaction= false;
 768         final boolean fetchTemplatesFromDB = false;
 769
 770
 771         when(csarUtils.createCsar(eq(component), eq(false), eq(false))).thenReturn(Either.right(expectedResponseFormat));
 772         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> response =
 773                 testArtifactsBusinessLogic.generateAndSaveToscaArtifact(
 774                         artifactDefinition, component, user,
 775                         isInCertificationRequest, shouldLock, inTransaction, fetchTemplatesFromDB);
 776
 777         assertTrue(response.isRight());
 778         assertEquals(response.right().value(), expectedResponseFormat);
 779     }
 780
 781     @Test
 782     public void validateGenerateAndSaveToscaArtifactResponseProperlyToGenerationFail() {
 783         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 784
 785         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 786
 787         final byte[] byteResponse= "testBytes".getBytes();
 788         final byte[] testPayloadData = "testPayloadData".getBytes();
 789         final String testESId = "testEsId";
 790         final ArtifactDefinition artifactDefinition = Mockito.mock(ArtifactDefinition.class);
 791         when(artifactDefinition.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_CSAR.getType());
 792         when(artifactDefinition.getPayloadData()).thenReturn(testPayloadData);
 793         when(artifactDefinition.getEsId()).thenReturn(testESId);
 794         final String artifactName = "testArtifact";
 795         final String componentUniqueId = "testUniqueId";
 796         final Resource component = Mockito.mock(Resource.class);
 797         when(component.getComponentType()).thenReturn(ComponentTypeEnum.RESOURCE);
 798         when(component.getUniqueId()).thenReturn(componentUniqueId);
 799         when(component.getName()).thenReturn(artifactName);
 800         final User user = new User();
 801         final boolean isInCertificationRequest = false;
 802         final boolean shouldLock = false;
 803         final boolean inTransaction= false;
 804         final boolean fetchTemplatesFromDB = false;
 805         final ComponentsUtils testComponentUtils = Mockito.mock(ComponentsUtils.class);
 806         when(testComponentUtils.getResponseFormat(eq(ActionStatus.OK))).thenReturn(expectedResponseFormat);
 807
 808         when(artifactCassandraDao.saveArtifact(any(ESArtifactData.class))).thenReturn(CassandraOperationStatus.OK);
 809         when(artifactToscaOperation.updateArtifactOnResource(
 810                 eq(artifactDefinition), eq(componentUniqueId), eq(null),
 811                 eq(NodeTypeEnum.Resource), eq(componentUniqueId)
 812         )).thenReturn(Either.left(artifactDefinition));
 813         when(csarUtils.createCsar(eq(component), eq(false), eq(false))).thenReturn(Either.left(byteResponse));
 814         testArtifactsBusinessLogic.setComponentsUtils(testComponentUtils);
 815         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> response =
 816                 testArtifactsBusinessLogic.generateAndSaveToscaArtifact(
 817                         artifactDefinition, component, user,
 818                         isInCertificationRequest, shouldLock, inTransaction, fetchTemplatesFromDB);
 819         assertTrue(response.isLeft());
 820         assertTrue(response.isLeft());
 821         assertEquals(response.left().value().left().value(), artifactDefinition);
 822     }
 823
 824     @Test
 825     public void validateHandleDownloadToscaModelRequestReturnsProperResponseFormat() {
 826         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 827
 828         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 829
 830         final Component component = Mockito.mock(Component.class);
 831         final String testESId = "testEsId";
 832         final String artifactName = "testArtifact";
 833         final ArtifactDefinition artifactDefinition = Mockito.mock(ArtifactDefinition.class);
 834         when(artifactDefinition.getEsId()).thenReturn(testESId);
 835         when(artifactDefinition.getArtifactDisplayName()).thenReturn(artifactName);
 836         final ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
 837         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.OK))).thenReturn(ActionStatus.OK);
 838         when(componentsUtils.getResponseFormatByArtifactId(
 839                 eq(ActionStatus.OK), eq(artifactName))).thenReturn(expectedResponseFormat);
 840
 841         when(artifactCassandraDao.getArtifact(eq(testESId))).thenReturn(Either.right(CassandraOperationStatus.OK));
 842
 843         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 844
 845         Either<ImmutablePair<String, byte[]>, ResponseFormat> response =
 846                 testArtifactsBusinessLogic.handleDownloadToscaModelRequest(component,artifactDefinition);
 847
 848         assertTrue(response.isRight());
 849         assertEquals(response.right().value(), expectedResponseFormat);
 850     }
 851
 852     @Test
 853     public void validateHandleDownloadRequestByIdReturnsProperResponseFormat() {
 854         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 855
 856         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 857
 858         final String componentId = "testComponent";
 859         final String artifactId = "testArtifact";
 860         final String userId = "testUser";
 861         final ComponentTypeEnum componentType = ComponentTypeEnum.SERVICE;
 862         final String parentId = "testParent";
 863         final String containerComponentType = "products";
 864         final User user = new User();
 865         final Service component = Mockito.mock(Service.class);
 866         when(component.getUniqueId()).thenReturn(componentId);
 867         final UserValidations userValidations = Mockito.mock(UserValidations.class);
 868         when(userValidations.validateUserExists(
 869                 eq(userId), eq("ArtifactDownload"), eq(false))).thenReturn(user);
 870
 871         when(toscaOperationFacade.getToscaFullElement(eq(componentId))).thenReturn(Either.left(component));
 872         when(artifactToscaOperation.getArtifactById(componentId, artifactId, componentType, componentId)).
 873                 thenReturn(Either.right(StorageOperationStatus.OK));
 874         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.OK))).thenReturn(ActionStatus.OK);
 875         when(componentsUtils.getResponseFormat(eq(ActionStatus.OK))).thenReturn(expectedResponseFormat);
 876
 877         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 878         testArtifactsBusinessLogic.setUserValidations(userValidations);
 879
 880         Either<ImmutablePair<String, byte[]>, ResponseFormat> response =
 881                 testArtifactsBusinessLogic.handleDownloadRequestById(
 882                         componentId, artifactId, userId,
 883                         componentType, parentId, containerComponentType);
 884
 885         assertTrue(response.isRight());
 886         assertEquals(response.right().value(), expectedResponseFormat);
 887     }
 888
 889     @Test
 890     public void testIfValidateArtifactTypeExistsRespondsWithNotSupportedFormat() {
 891
 892         final Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
 893         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
 894         when(artifactInfo.getArtifactType()).thenReturn("WrongFormat");
 895
 896         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 897
 898         testArtifactsBusinessLogic.validateArtifactTypeExists(responseWrapper,artifactInfo);
 899
 900         assertEquals(responseWrapper.getInnerElement().getStatus().intValue(), HttpStatus.SC_BAD_REQUEST);
 901     }
 902
 903     @Test
 904     public void testIfValidateFileExtensionRespondsWithCorrectResult() {
 905         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 906
 907         final Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
 908         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
 909         when(artifactInfo.getArtifactName()).thenReturn("test.heat");
 910         final ArtifactTypeConfig artifactTypeConfig =
 911                 Mockito.mock(ArtifactTypeConfig.class);
 912         when(artifactTypeConfig.getAcceptedTypes()).thenReturn(Collections.singletonList("heat"));
 913         final IDeploymentArtifactTypeConfigGetter deploymentConfigGetter =
 914                 Mockito.mock(IDeploymentArtifactTypeConfigGetter.class);
 915         when(deploymentConfigGetter.getDeploymentArtifactConfig()).
 916                 thenReturn(artifactTypeConfig);
 917         final NodeTypeEnum parentType = NodeTypeEnum.Service;
 918         final ArtifactTypeEnum artifactType = ArtifactTypeEnum.HEAT;
 919
 920         testArtifactsBusinessLogic.validateFileExtension(
 921                 responseWrapper, deploymentConfigGetter, artifactInfo,
 922                 parentType, artifactType);
 923
 924         assertTrue(responseWrapper.isEmpty());
 925     }
 926
 927     @Test
 928     public void testIfValidateFileExtensionRespondsWithGeneralErrorIfNodeTypeIsWrong() {
 929         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 930
 931         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 932         final Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
 933         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
 934         final IDeploymentArtifactTypeConfigGetter deploymentConfigGetter =
 935                 Mockito.mock(IDeploymentArtifactTypeConfigGetter.class);
 936         final NodeTypeEnum parentType = NodeTypeEnum.Group;
 937         final ArtifactTypeEnum artifactType = ArtifactTypeEnum.HEAT;
 938
 939         when(componentsUtils.getResponseFormat(eq(ActionStatus.GENERAL_ERROR))).thenReturn(expectedResponseFormat);
 940
 941         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 942
 943         testArtifactsBusinessLogic.validateFileExtension(
 944                 responseWrapper, deploymentConfigGetter, artifactInfo,
 945                 parentType, artifactType);
 946
 947         assertFalse(responseWrapper.isEmpty());
 948         assertEquals(responseWrapper.getInnerElement(),expectedResponseFormat);
 949     }
 950
 951     @Test
 952     public void testIfValidateFileExtensionRespondsWithArtifactTypeNotSupportedIfAcceptedTypeIsNull() {
 953         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 954
 955         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 956         final Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
 957         final String testArtifactType = "testArtifact";
 958         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
 959         when(artifactInfo.getArtifactType()).thenReturn(testArtifactType);
 960         final IDeploymentArtifactTypeConfigGetter deploymentConfigGetter =
 961                 Mockito.mock(IDeploymentArtifactTypeConfigGetter.class);
 962         final NodeTypeEnum parentType = NodeTypeEnum.Resource;
 963         final ArtifactTypeEnum artifactType = ArtifactTypeEnum.HEAT;
 964
 965         when(componentsUtils.getResponseFormat(eq(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED), eq(testArtifactType))).thenReturn(expectedResponseFormat);
 966
 967         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 968
 969         testArtifactsBusinessLogic.validateFileExtension(
 970                 responseWrapper, deploymentConfigGetter, artifactInfo,
 971                 parentType, artifactType);
 972
 973         assertFalse(responseWrapper.isEmpty());
 974         assertEquals(responseWrapper.getInnerElement(),expectedResponseFormat);
 975     }
 976
 977     @Test
 978     public void testIfValidateFileExtensionRespondsWithWrongArtifactTypeExtensionIfExtensionIsNotAccepted() {
 979         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
 980
 981         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
 982         final Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
 983         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
 984         when(artifactInfo.getArtifactName()).thenReturn("test.heat");
 985         final ArtifactTypeConfig artifactTypeConfig =
 986                 Mockito.mock(ArtifactTypeConfig.class);
 987         when(artifactTypeConfig.getAcceptedTypes()).thenReturn(Collections.singletonList("yaml"));
 988         final IDeploymentArtifactTypeConfigGetter deploymentConfigGetter =
 989                 Mockito.mock(IDeploymentArtifactTypeConfigGetter.class);
 990         when(deploymentConfigGetter.getDeploymentArtifactConfig()).
 991                 thenReturn(artifactTypeConfig);
 992         final NodeTypeEnum parentType = NodeTypeEnum.Service;
 993         final ArtifactTypeEnum artifactType = ArtifactTypeEnum.HEAT;
 994
 995         when(componentsUtils.getResponseFormat(eq(ActionStatus.WRONG_ARTIFACT_FILE_EXTENSION), eq(artifactType.getType()))).thenReturn(expectedResponseFormat);
 996
 997         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
 998
 999         testArtifactsBusinessLogic.validateFileExtension(
1000                 responseWrapper, deploymentConfigGetter, artifactInfo,
1001                 parentType, artifactType);
1002
1003         assertFalse(responseWrapper.isEmpty());
1004         assertEquals(responseWrapper.getInnerElement(),expectedResponseFormat);
1005     }
1006
1007     @Test
1008     public void validateFillArtifactPayloadValidationReturnsNoErrorIfCalledWithProperParameters() {
1009         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1010
1011         final Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1012         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
1013         when(artifactInfo.getPayloadData()).thenReturn("artifactInfoPayload".getBytes());
1014         final Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1015
1016         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
1017
1018         testArtifactsBusinessLogic.fillArtifactPayloadValidation(errorWrapper, payloadWrapper, artifactInfo);
1019
1020         assertEquals(artifactInfo.getPayloadData(),payloadWrapper.getInnerElement());
1021     }
1022
1023     @Test
1024     public void validateFillArtifactPayloadValidationReturnsNoErrorIfCalledWithEmptyArtifactPayloadButPayloadIsInCasandraDao() {
1025         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1026
1027         final Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1028         final String esId = "testEsId";
1029         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
1030         when(artifactInfo.getPayloadData()).thenReturn("".getBytes());
1031         when(artifactInfo.getEsId()).thenReturn(esId);
1032         final Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1033         final byte[] payloadArtifactData = "testArtifactData".getBytes();
1034         final byte[] base64PayloadArtifactData = Base64.decodeBase64(payloadArtifactData);
1035         final ESArtifactData artifactData = Mockito.mock(ESArtifactData.class);
1036         when(artifactData.getDataAsArray()).thenReturn(base64PayloadArtifactData);
1037
1038         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
1039
1040         when(artifactCassandraDao.getArtifact(esId)).thenReturn(Either.left(artifactData));
1041
1042         testArtifactsBusinessLogic.fillArtifactPayloadValidation(errorWrapper, payloadWrapper, artifactInfo);
1043
1044         assertFalse(payloadWrapper.isEmpty());
1045         assertArrayEquals(payloadWrapper.getInnerElement(), payloadArtifactData);
1046     }
1047
1048     @Test
1049     public void validateFillArtifactPayloadValidationReturnsErrorIfCalledWithEmptyArtifactPayloadAndNoPayloadInCasandraDao() {
1050         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1051
1052         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
1053         final Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1054         final String esId = "testEsId";
1055         final ArtifactDefinition artifactInfo = Mockito.mock(ArtifactDefinition.class);
1056         when(artifactInfo.getPayloadData()).thenReturn("".getBytes());
1057         when(artifactInfo.getEsId()).thenReturn(esId);
1058         final Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1059
1060         when(artifactCassandraDao.getArtifact(esId)).thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
1061         when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.GENERAL_ERROR)).thenReturn(ActionStatus.ERROR_DURING_CSAR_CREATION);
1062         when(componentsUtils.getResponseFormat(eq(ActionStatus.ERROR_DURING_CSAR_CREATION))).thenReturn(expectedResponseFormat);
1063
1064         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
1065         testArtifactsBusinessLogic.fillArtifactPayloadValidation(errorWrapper, payloadWrapper, artifactInfo);
1066
1067         assertFalse(errorWrapper.isEmpty());
1068         assertEquals(errorWrapper.getInnerElement(),expectedResponseFormat);
1069     }
1070
1071     @Test
1072     public void validateGetDeploymentArtifactsReturnsCorrectArtifactLists() {
1073         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1074
1075         final Component parentComponent = Mockito.mock(Component.class);
1076         final ArtifactDefinition artifactDefinition = Mockito.mock(ArtifactDefinition.class);
1077         when(parentComponent.getDeploymentArtifacts()).thenReturn(Collections.singletonMap("testService", artifactDefinition));
1078         final NodeTypeEnum parentType = NodeTypeEnum.Service;
1079         final String ciId = "testCiId";
1080
1081         List<ArtifactDefinition> result = testArtifactsBusinessLogic.getDeploymentArtifacts(parentComponent, parentType, ciId);
1082
1083         assertEquals(result.size(), 1);
1084         assertEquals(result.get(0), artifactDefinition);
1085     }
1086
1087     @Test
1088     public void validateGetDeploymentArtifactsReturnsCorrectArtifactListsForResourceInstance() {
1089         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1090
1091         final String ciId = "testCiId";
1092         final ArtifactDefinition deploymentArtifact = Mockito.mock(ArtifactDefinition.class);
1093         final  Map<String, ArtifactDefinition> deploymentArtifacts = Collections.singletonMap("",deploymentArtifact);
1094         final ComponentInstance componentInstance = Mockito.mock(ComponentInstance.class);
1095         when(componentInstance.getUniqueId()).thenReturn(ciId);
1096         when(componentInstance.getDeploymentArtifacts()).thenReturn(deploymentArtifacts);
1097         final Component parentComponent = Mockito.mock(Component.class);
1098         when(parentComponent.getComponentInstances()).thenReturn(Collections.singletonList(componentInstance));
1099         final NodeTypeEnum parentType = NodeTypeEnum.ResourceInstance;
1100
1101         List<ArtifactDefinition> result = testArtifactsBusinessLogic.getDeploymentArtifacts(parentComponent, parentType, ciId);
1102
1103         assertEquals(result.size(), 1);
1104         assertEquals(result.get(0), deploymentArtifact);
1105     }
1106
1107     @Test
1108     public void validateHandleGetArtifactsByTypeReturnsProperArtifact() {
1109         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1110
1111         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
1112         final String containerComponentType = "services";
1113         final String parentId = "testParentId";
1114         final ComponentTypeEnum componentType = ComponentTypeEnum.SERVICE;
1115         final String componentId = "testComponentId";
1116         final String artifactGroupType = "testArtifactGroupType";
1117         final String userId = "testUserId";
1118         final User user = new User();
1119
1120         final UserValidations userValidations = Mockito.mock(UserValidations.class);
1121         when(userValidations.validateUserExists(eq(userId), eq("get artifacts"), eq(false)))
1122                 .thenReturn(user);
1123
1124
1125         when(toscaOperationFacade.getToscaElement(eq(componentId), any(ComponentParametersView.class)))
1126                 .thenReturn(Either.right(StorageOperationStatus.OK));
1127         when(componentsUtils.convertFromStorageResponse(
1128                 eq(StorageOperationStatus.OK), eq(ComponentTypeEnum.SERVICE)))
1129                 .thenReturn(ActionStatus.OK);
1130         when(componentsUtils.getResponseFormat(eq(ActionStatus.OK), eq(componentId)))
1131                 .thenReturn(expectedResponseFormat);
1132
1133         testArtifactsBusinessLogic.setUserValidations(userValidations);
1134         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
1135
1136         Either<Map<String, ArtifactDefinition>, ResponseFormat> response =
1137                 testArtifactsBusinessLogic.handleGetArtifactsByType(
1138                         containerComponentType, parentId, componentType,
1139                         componentId, artifactGroupType, userId
1140                 );
1141
1142         assertTrue(response.isRight());
1143         assertEquals(response.right().value(), expectedResponseFormat);
1144     }
1145
1146     @Test
1147     public void validateHandleGetArtifactsByTypeReturnsMissingInformationIfUserIdIsNull() {
1148         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1149
1150         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
1151         final String containerComponentType = "services";
1152         final String parentId = "testParentId";
1153         final ComponentTypeEnum componentType = ComponentTypeEnum.SERVICE;
1154         final String componentId = "testComponentId";
1155         final String artifactGroupType = "testArtifactGroupType";
1156         final String userId = null;
1157
1158         when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_INFORMATION)))
1159                 .thenReturn(expectedResponseFormat);
1160
1161         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
1162
1163         Either<Map<String, ArtifactDefinition>, ResponseFormat> response =
1164                 testArtifactsBusinessLogic.handleGetArtifactsByType(
1165                         containerComponentType, parentId, componentType,
1166                         componentId, artifactGroupType, userId
1167                 );
1168
1169         assertTrue(response.isRight());
1170         assertEquals(response.right().value(), expectedResponseFormat);
1171     }
1172
1173     @Test
1174     public void validateDeleteArtifactByInterfaceReturnsProperResponse() {
1175         ArtifactsBusinessLogic testArtifactsBusinessLogic = getArtifactsBusinessLogic();
1176
1177         final ResponseFormat expectedResponseFormat = Mockito.mock(ResponseFormat.class);
1178         final String resourceId = "testResources";
1179         final String userId = "testUser";
1180         final String artifactId = "testArtifact";
1181         final boolean inTransaction = false;
1182         final String serviceId = "testService";
1183         final Resource resource =  Mockito.mock(Resource.class);
1184         when(resource.getUniqueId()).thenReturn(serviceId);
1185
1186         when(toscaOperationFacade.getToscaElement(resourceId, JsonParseFlagEnum.ParseMetadata))
1187                 .thenReturn(Either.left(resource));
1188         when(toscaOperationFacade.getToscaElement(serviceId)).thenReturn(Either.right(StorageOperationStatus.OK));
1189         when(componentsUtils.getResponseFormat(ActionStatus.OK))
1190                 .thenReturn(expectedResponseFormat);
1191         when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.OK))
1192                 .thenReturn(ActionStatus.OK);
1193         when(componentsUtils.getResponseFormatByArtifactId(ActionStatus.OK, artifactId))
1194                 .thenReturn(expectedResponseFormat);
1195         testArtifactsBusinessLogic.setComponentsUtils(componentsUtils);
1196
1197         Either<Operation, ResponseFormat> response =
1198                 testArtifactsBusinessLogic.deleteArtifactByInterface(
1199                         resourceId, userId, artifactId, inTransaction
1200                 );
1201
1202         assertTrue(response.isRight());
1203         assertEquals(response.right().value(),expectedResponseFormat);
1204     }
1205
1206     private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
1207         assertThat(heatYamlParam.getCurrentValue()).isEqualTo(heatEnvParam.getDefaultValue());
1208         assertThat(heatEnvParam.getCurrentValue()).isNull();
1209     }
1210 }