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  */
  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 mockit.Deencapsulation;
  32 import org.apache.commons.lang3.tuple.ImmutablePair;
  33 import org.junit.Before;
  34 import org.junit.Test;
  35 import org.mockito.InjectMocks;
  36 import org.mockito.Mock;
  37 import org.mockito.Mockito;
  38 import org.mockito.MockitoAnnotations;
  39 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  40 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo;
  41 import org.openecomp.sdc.be.components.utils.ArtifactBuilder;
  42 import org.openecomp.sdc.be.components.utils.ObjectGenerator;
  43 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
  44 import org.openecomp.sdc.be.config.ConfigurationManager;
  45 import org.openecomp.sdc.be.dao.api.ActionStatus;
  46 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  47 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  48 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  49 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  50 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  53 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  54 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  55 import org.openecomp.sdc.be.impl.ComponentsUtils;
  56 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
  57 import org.openecomp.sdc.be.model.ArtifactDefinition;
  58 import org.openecomp.sdc.be.model.ArtifactType;
  59 import org.openecomp.sdc.be.model.Component;
  60 import org.openecomp.sdc.be.model.ComponentInstance;
  61 import org.openecomp.sdc.be.model.DataTypeDefinition;
  62 import org.openecomp.sdc.be.model.GroupDefinition;
  63 import org.openecomp.sdc.be.model.GroupInstance;
  64 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  65 import org.openecomp.sdc.be.model.InterfaceDefinition;
  66 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  67 import org.openecomp.sdc.be.model.Operation;
  68 import org.openecomp.sdc.be.model.Resource;
  69 import org.openecomp.sdc.be.model.Service;
  70 import org.openecomp.sdc.be.model.User;
  71 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  72 import org.openecomp.sdc.be.model.jsontitan.operations.ArtifactsOperations;
  73 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
  74 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  75 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  76 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  77 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  78 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  79 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  80 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
  81 import org.openecomp.sdc.be.resources.data.ESArtifactData;
  82 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  83 import org.openecomp.sdc.be.servlets.RepresentationUtils;
  84 import org.openecomp.sdc.be.user.Role;
  85 import org.openecomp.sdc.be.user.UserBusinessLogic;
  86 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  87 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  88 import org.openecomp.sdc.common.api.ConfigurationSource;
  89 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  90 import org.openecomp.sdc.common.datastructure.Wrapper;
  91 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  92 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  93 import org.openecomp.sdc.exception.ResponseFormat;
  94
  95 import java.io.IOException;
  96 import java.util.ArrayList;
  97 import java.util.Collections;
  98 import java.util.HashMap;
  99 import java.util.List;
 100 import java.util.Map;
 101
 102 import static org.junit.Assert.assertEquals;
 103 import static org.junit.Assert.assertNull;
 104 import static org.junit.Assert.assertTrue;
 105 import static org.mockito.ArgumentMatchers.any;
 106 import static org.mockito.ArgumentMatchers.anyBoolean;
 107 import static org.mockito.ArgumentMatchers.anyString;
 108 import static org.mockito.ArgumentMatchers.eq;
 109 import static org.mockito.Mockito.times;
 110 import static org.mockito.Mockito.verify;
 111 import static org.mockito.Mockito.when;
 112 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
 113 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
 114
 115 public class ArtifactsBusinessLogicTest {
 116
 117         public static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN",
 118                         System.currentTimeMillis());
 119         private final static String RESOURCE_INSTANCE_NAME = "Service-111";
 120         private final static String INSTANCE_ID = "S-123-444-ghghghg";
 121
 122         private final static String ARTIFACT_NAME = "service-Myservice-template.yml";
 123         private final static String ARTIFACT_LABEL = "assettoscatemplate";
 124         private final static String ES_ARTIFACT_ID = "123123dfgdfgd0";
 125         private final static byte[] PAYLOAD = "some payload".getBytes();
 126         public static final String RESOURCE_NAME = "My-Resource_Name with   space";
 127         public static final String RESOURCE_CATEGORY = "Network Layer 2-3/Router";
 128         public static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 129         public static final String RESOURCE_SUBCATEGORY = "Router";
 130         final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 131
 132         TitanDao mockTitanDao = Mockito.mock(TitanDao.class);
 133
 134         static ConfigurationSource configurationSource = new FSConfigurationSource(
 135                         ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
 136         static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 137
 138         @InjectMocks
 139         private static ArtifactsBusinessLogic artifactBL;
 140
 141         private static User user = null;
 142         private static Resource resourceResponse = null;
 143         private static ResponseFormatManager responseManager = null;
 144
 145         @Mock
 146         private UserBusinessLogic userBusinessLogic;
 147         @Mock
 148         private ArtifactOperation artifactOperation;
 149         @Mock
 150         public ComponentsUtils componentsUtils;
 151         @Mock
 152         private IInterfaceLifecycleOperation lifecycleOperation;
 153         @Mock
 154         private IUserAdminOperation userOperation;
 155         @Mock
 156         private IElementOperation elementOperation;
 157         @Mock
 158         private ArtifactCassandraDao artifactCassandraDao;
 159         @Mock
 160         public ToscaOperationFacade toscaOperationFacade;
 161         @Mock
 162         private NodeTemplateOperation nodeTemplateOperation;
 163         @Mock
 164         private ArtifactsOperations artifactsOperations;
 165         @Mock
 166         private IGraphLockOperation graphLockOperation;
 167         @Mock
 168         TitanDao titanDao;
 169
 170         public static final Resource resource = Mockito.mock(Resource.class);
 171         private Gson gson = new GsonBuilder().setPrettyPrinting().create();
 172
 173         private static List<ArtifactType> getAllTypes() {
 174                 List<ArtifactType> artifactTypes = new ArrayList<ArtifactType>();
 175                 List<String> artifactTypesList = ConfigurationManager.getConfigurationManager().getConfiguration()
 176                                 .getArtifactTypes();
 177                 for (String artifactType : artifactTypesList) {
 178                         ArtifactType artifactT = new ArtifactType();
 179                         artifactT.setName(artifactType);
 180                         artifactTypes.add(artifactT);
 181                 }
 182                 return artifactTypes;
 183         }
 184
 185         @Before
 186         public void initMocks() {
 187                 MockitoAnnotations.initMocks(this);
 188                 Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
 189                                 .right(StorageOperationStatus.NOT_FOUND);
 190
 191                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either
 192                                 .right(StorageOperationStatus.NOT_FOUND);
 193                 when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Service), Mockito.anyBoolean()))
 194                                 .thenReturn(NotFoundResult2);
 195                 when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Resource), Mockito.anyBoolean()))
 196                                 .thenReturn(NotFoundResult2);
 197
 198                 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
 199                                 .right(StorageOperationStatus.NOT_FOUND);
 200                 when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
 201                                 .thenReturn(notFoundInterfaces);
 202
 203                 Either<User, ActionStatus> getUserResult = Either.left(USER);
 204
 205                 when(userOperation.getUserData("jh0003", false)).thenReturn(getUserResult);
 206
 207                 Either<List<ArtifactType>, ActionStatus> getType = Either.left(getAllTypes());
 208                 when(elementOperation.getAllArtifactTypes()).thenReturn(getType);
 209
 210                 when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
 211
 212                 // User data and management
 213                 user = new User();
 214                 user.setUserId("jh0003");
 215                 user.setFirstName("Jimmi");
 216                 user.setLastName("Hendrix");
 217                 user.setRole(Role.ADMIN.name());
 218
 219                 // createResource
 220                 resourceResponse = createResourceObject(true);
 221                 Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 222                 Either<Integer, StorageOperationStatus> eitherValidate = Either.left(null);
 223                 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 224                 when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate);
 225                 Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
 226                 when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 227                 when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK);
 228
 229                 Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
 230                                 .right(StorageOperationStatus.BAD_REQUEST);
 231                 when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
 232                                 .thenReturn(resourceStorageOperationStatusEither);
 233         }
 234
 235         @Test
 236         public void testValidJson() {
 237                 ArtifactDefinition ad = createArtifactDef();
 238
 239                 String jsonArtifact = "";
 240
 241                 ObjectMapper mapper = new ObjectMapper();
 242                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 243                 mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 244                 mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 245
 246                 try {
 247                         jsonArtifact = mapper.writeValueAsString(ad);
 248                 } catch (IOException e) {
 249                         // TODO Auto-generated catch block
 250                         e.printStackTrace();
 251                 }
 252
 253                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
 254                                 ArtifactDefinition.class);
 255                 assertEquals(ad, afterConvert);
 256         }
 257
 258         private ArtifactDefinition createArtifactDef() {
 259                 ArtifactDefinition ad = new ArtifactDefinition();
 260                 ad.setArtifactName("artifact1.yaml");
 261                 ad.setArtifactLabel("label1");
 262                 ad.setDescription("description");
 263                 ad.setArtifactType(ArtifactTypeEnum.HEAT.getType());
 264                 ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 265                 ad.setCreationDate(System.currentTimeMillis());
 266                 ad.setMandatory(false);
 267                 ad.setTimeout(15);
 268                 return ad;
 269         }
 270
 271         private Resource createResourceObject(boolean afterCreate) {
 272                 Resource resource = new Resource();
 273                 resource.setName(RESOURCE_NAME);
 274                 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 275                 resource.setDescription("My short description");
 276                 List<String> tgs = new ArrayList<String>();
 277                 tgs.add("test");
 278                 tgs.add(resource.getName());
 279                 resource.setTags(tgs);
 280                 List<String> template = new ArrayList<String>();
 281                 template.add("Root");
 282                 resource.setDerivedFrom(template);
 283                 resource.setVendorName("Motorola");
 284                 resource.setVendorRelease("1.0.0");
 285                 resource.setContactId("ya5467");
 286                 resource.setIcon("MyIcon");
 287
 288                 if (afterCreate) {
 289                         resource.setName(resource.getName());
 290                         resource.setVersion("0.1");
 291                         resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 292                         resource.setCreatorUserId(user.getUserId());
 293                         resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 294                         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 295                 }
 296                 return resource;
 297         }
 298
 299         @Test
 300         public void testInvalidStringGroupType() {
 301                 ArtifactDefinition ad = new ArtifactDefinition();
 302                 ad.setArtifactName("artifact1");
 303                 ad.setCreationDate(System.currentTimeMillis());
 304                 ad.setMandatory(false);
 305                 ad.setTimeout(15);
 306
 307                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 308                 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
 309
 310                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 311                                 ArtifactDefinition.class);
 312                 assertNull(afterConvert);
 313         }
 314
 315         @Test
 316         public void testInvalidNumberGroupType() {
 317                 ArtifactDefinition ad = new ArtifactDefinition();
 318                 ad.setArtifactName("artifact1");
 319                 ad.setCreationDate(System.currentTimeMillis());
 320                 ad.setMandatory(false);
 321                 ad.setTimeout(15);
 322
 323                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 324                 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
 325
 326                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 327                                 ArtifactDefinition.class);
 328                 assertNull(afterConvert);
 329         }
 330
 331         @Test
 332         public void testInvalidGroupTypeWithSpace() {
 333                 ArtifactDefinition ad = new ArtifactDefinition();
 334                 ad.setArtifactName("artifact1");
 335                 ad.setCreationDate(System.currentTimeMillis());
 336                 ad.setMandatory(false);
 337                 ad.setTimeout(15);
 338
 339                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 340                 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 341
 342                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 343                                 ArtifactDefinition.class);
 344                 assertNull(afterConvert);
 345         }
 346
 347         @Test
 348         public void testInvalidTimeoutWithSpace() {
 349                 ArtifactDefinition ad = new ArtifactDefinition();
 350                 ad.setArtifactName("artifact1");
 351                 ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 352                 ad.setCreationDate(System.currentTimeMillis());
 353                 ad.setMandatory(false);
 354
 355                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 356                 jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
 357
 358                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 359                                 ArtifactDefinition.class);
 360                 assertNull(afterConvert);
 361         }
 362
 363         @Test
 364         public void testValidMibAritactsConfiguration() {
 365                 Map<String, ArtifactTypeConfig> componentDeploymentArtifacts = ConfigurationManager.getConfigurationManager()
 366                                 .getConfiguration().getResourceDeploymentArtifacts();
 367                 Map<String, ArtifactTypeConfig> componentInstanceDeploymentArtifacts = ConfigurationManager
 368                                 .getConfigurationManager().getConfiguration().getResourceInstanceDeploymentArtifacts();
 369                 assertTrue(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType()));
 370                 assertTrue(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType()));
 371                 assertTrue(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType()));
 372                 assertTrue(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType()));
 373         }
 374
 375         @Test
 376         public void testDownloadServiceArtifactByNames() {
 377                 Service service = new Service();
 378                 String serviceName = "myService";
 379                 String serviceVersion = "1.0";
 380                 String serviceId = "serviceId";
 381                 service.setName(serviceName);
 382                 service.setVersion(serviceVersion);
 383                 service.setUniqueId(serviceId);
 384
 385                 String artifactName = "service-Myservice-template.yml";
 386                 String artifactLabel = "assettoscatemplate";
 387                 String esArtifactId = "123123dfgdfgd0";
 388                 byte[] payload = "some payload".getBytes();
 389                 ArtifactDefinition toscaTemplateArtifact = new ArtifactDefinition();
 390                 toscaTemplateArtifact.setArtifactName(artifactName);
 391                 toscaTemplateArtifact.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 392                 toscaTemplateArtifact.setArtifactLabel(artifactLabel);
 393                 toscaTemplateArtifact.setEsId(esArtifactId);
 394                 toscaTemplateArtifact.setPayload(payload);
 395
 396                 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 397                 toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
 398                 service.setToscaArtifacts(toscaArtifacts);
 399
 400                 ESArtifactData esArtifactData = new ESArtifactData(esArtifactId);
 401                 esArtifactData.setDataAsArray(payload);
 402                 Either<ESArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(esArtifactData);
 403                 when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
 404                 List<org.openecomp.sdc.be.model.Component> serviceList = new ArrayList<>();
 405                 serviceList.add(service);
 406                 Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> getServiceRes = Either
 407                                 .left(serviceList);
 408                 when(toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName)).thenReturn(getServiceRes);
 409                 Either<byte[], ResponseFormat> downloadServiceArtifactByNamesRes = artifactBL
 410                                 .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
 411                 assertTrue(downloadServiceArtifactByNamesRes.isLeft());
 412                 assertTrue(downloadServiceArtifactByNamesRes.left().value() != null
 413                                 && downloadServiceArtifactByNamesRes.left().value().length == payload.length);
 414         }
 415
 416         @Test
 417         public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
 418                 ArtifactDefinition heatArtifact = new ArtifactBuilder()
 419                                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
 420                                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
 421
 422                 Resource component = new Resource();
 423                 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(Either.left(USER));
 424                 when(artifactsOperations.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 425                                 eq(component.getUniqueId()), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 426                                                 .thenReturn(Either.left(new ArtifactDefinition()));
 427                 Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 428                                 heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
 429                                 Collections.emptyMap());
 430                 assertTrue(heatEnvPlaceHolder.isLeft());
 431                 assertNull(heatEnvPlaceHolder.left().value().getListHeatParameters());
 432         }
 433
 434         @Test
 435         public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
 436                         throws Exception {
 437                 HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
 438                 HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
 439                 HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
 440                 ArtifactDefinition heatArtifact = new ArtifactBuilder().addHeatParam(heatParam1).addHeatParam(heatParam2)
 441                                 .addHeatParam(heatParam3).build();
 442
 443                 Resource component = new Resource();
 444
 445                 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(Either.left(USER));
 446                 when(artifactsOperations.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 447                                 eq(component.getUniqueId()), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 448                                                 .thenReturn(Either.left(new ArtifactDefinition()));
 449
 450                 Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 451                                 heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
 452                                 Collections.emptyMap());
 453
 454                 assertTrue(heatEnvPlaceHolder.isLeft());
 455                 ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder.left().value();
 456                 List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
 457                 assertEquals(listHeatParameters.size(), 3);
 458                 verifyHeatParam(listHeatParameters.get(0), heatParam1);
 459                 verifyHeatParam(listHeatParameters.get(1), heatParam2);
 460                 verifyHeatParam(listHeatParameters.get(2), heatParam3);
 461         }
 462
 463         @Test
 464         public void buildArtifactPayloadWhenShouldLockAndInTransaction() {
 465                 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 466                 artifactDefinition.setArtifactName(ARTIFACT_NAME);
 467                 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 468                 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 469                 artifactDefinition.setEsId(ES_ARTIFACT_ID);
 470                 artifactDefinition.setPayload(PAYLOAD);
 471                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 472
 473                 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 474                 when(artifactsOperations.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 475                                 any(NodeTypeEnum.class), any(String.class))).thenReturn(Either.left(artifactDefinition));
 476                 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 477                 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 478                 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 479                                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
 480         }
 481
 482         @Test
 483         public void buildArtifactPayloadWhenShouldLockAndNotInTransaction() {
 484                 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 485                 artifactDefinition.setArtifactName(ARTIFACT_NAME);
 486                 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 487                 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 488                 artifactDefinition.setEsId(ES_ARTIFACT_ID);
 489                 artifactDefinition.setPayload(PAYLOAD);
 490                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 491
 492                 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 493                 when(artifactsOperations.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 494                                 any(NodeTypeEnum.class), any(String.class))).thenReturn(Either.left(artifactDefinition));
 495                 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 496                 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 497                 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 498                                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 499                 verify(titanDao, times(1)).commit();
 500         }
 501
 502
 503         private ArtifactDefinition buildArtifactPayload() {
 504                 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 505                 artifactDefinition.setArtifactName(ARTIFACT_NAME);
 506                 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 507                 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 508                 artifactDefinition.setEsId(ES_ARTIFACT_ID);
 509                 artifactDefinition.setPayload(PAYLOAD);
 510                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 511
 512                 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 513                 when(artifactsOperations.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 514                                 any(NodeTypeEnum.class), any(String.class))).thenReturn(Either.left(artifactDefinition));
 515                 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 516                 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 517                 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 518                                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 519                 verify(titanDao, times(1)).commit();
 520                 return artifactDefinition;
 521         }
 522
 523         private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
 524                 assertEquals(heatEnvParam.getDefaultValue(), heatYamlParam.getCurrentValue());
 525                 assertNull(heatEnvParam.getCurrentValue());
 526         }
 527
 528         private ArtifactsBusinessLogic createTestSubject() {
 529                 return new ArtifactsBusinessLogic();
 530         }
 531
 532         @Test
 533         public void testBuildJsonStringForCsarVfcArtifact() throws Exception {
 534                 ArtifactsBusinessLogic testSubject;
 535                 ArtifactDefinition artifact = new ArtifactDefinition();
 536                 String result;
 537
 538                 // default test
 539                 testSubject = createTestSubject();
 540                 result = Deencapsulation.invoke(testSubject, "buildJsonStringForCsarVfcArtifact", new Object[] { artifact });
 541         }
 542
 543         @Test
 544         public void testCheckArtifactInComponent() throws Exception {
 545                 ArtifactsBusinessLogic testSubject;
 546                 Component component = new Resource();
 547                 String artifactId = "";
 548                 boolean result;
 549
 550                 // default test
 551                 testSubject = createTestSubject();
 552                 result = Deencapsulation.invoke(testSubject, "checkArtifactInComponent",
 553                                 new Object[] { component, artifactId });
 554         }
 555
 556
 557
 558         @Test
 559         public void testCheckCreateFields() throws Exception {
 560                 ArtifactsBusinessLogic testSubject;
 561                 // User user = USER;
 562                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 563                 ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
 564
 565                 // default test
 566                 testSubject = createTestSubject();
 567                 Deencapsulation.invoke(testSubject, "checkCreateFields", new Object[] { user, artifactInfo, type });
 568         }
 569
 570
 571         @Test
 572         public void testComposeArtifactId() throws Exception {
 573                 ArtifactsBusinessLogic testSubject;
 574                 String resourceId = "";
 575                 String artifactId = "";
 576                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 577                 ;
 578                 String interfaceName = "";
 579                 String operationName = "";
 580                 String result;
 581
 582                 // test 1
 583                 testSubject = createTestSubject();
 584                 result = Deencapsulation.invoke(testSubject, "composeArtifactId",
 585                                 new Object[] { resourceId, artifactId, artifactInfo, interfaceName, operationName });
 586         }
 587
 588         @Test
 589         public void testConvertParentType() throws Exception {
 590                 ArtifactsBusinessLogic testSubject;
 591                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 592                 NodeTypeEnum result;
 593
 594                 // default test
 595                 testSubject = createTestSubject();
 596                 result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[] { componentType });
 597         }
 598
 599         @Test
 600         public void testConvertToOperation() throws Exception {
 601                 ArtifactsBusinessLogic testSubject;
 602                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 603                 String operationName = "";
 604                 Operation result;
 605
 606                 // default test
 607                 testSubject = createTestSubject();
 608                 result = Deencapsulation.invoke(testSubject, "convertToOperation",
 609                                 new Object[] { artifactInfo, operationName });
 610         }
 611
 612         @Test
 613         public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
 614                 ArtifactsBusinessLogic testSubject;
 615                 String operationName = "";
 616                 String artifactName = "";
 617                 String result;
 618
 619                 // default test
 620                 testSubject = createTestSubject();
 621                 result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
 622                                 new Object[] { operationName, artifactName });
 623         }
 624
 625         @Test
 626         public void testFetchArtifactsFromComponent() throws Exception {
 627                 ArtifactsBusinessLogic testSubject;
 628                 String artifactId = "";
 629                 Component component = createResourceObject(true);
 630                 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 631
 632                 // default test
 633                 testSubject = createTestSubject();
 634                 Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
 635                                 new Object[] { artifactId, component, artifacts });
 636         }
 637
 638
 639
 640
 641
 642
 643
 644
 645         @Test
 646         public void testValidateArtifact() throws Exception {
 647         ArtifactsBusinessLogic testSubject;String componentId = "";
 648         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 649         ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
 650         ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 651         String artifactId = "";
 652         ArtifactDefinition artifactInfo = buildArtifactPayload();
 653         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
 654
 655         Component component =  createResourceObject(true);
 656         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 657         boolean shouldLock = false;
 658         boolean inTransaction = false;
 659         ArtifactDefinition result;
 660
 661         // default test
 662         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "validateArtifact", new Object[]{componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, component, errorWrapper, shouldLock, inTransaction});
 663         }
 664
 665
 666         @Test
 667         public void testHandleHeatEnvDownload() throws Exception {
 668         ArtifactsBusinessLogic testSubject;String componentId = "";
 669         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 670
 671         Component component =  createResourceObject(true);
 672         ArtifactDefinition artifactInfo =  buildArtifactPayload();
 673         Either<ArtifactDefinition,ResponseFormat> validateArtifact = Either.left(artifactInfo);
 674         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 675         boolean shouldLock = false;
 676         boolean inTransaction = false;
 677
 678
 679         // default test
 680         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "handleHeatEnvDownload", new Object[]{componentId, componentType, user, component, validateArtifact, errorWrapper, shouldLock, inTransaction});
 681         }
 682
 683
 684         @Test
 685         public void testArtifactGenerationRequired() throws Exception {
 686                 ArtifactsBusinessLogic testSubject;
 687                 Component component =  createResourceObject(true);
 688                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 689                 boolean result;
 690
 691                 // default test
 692                 testSubject = createTestSubject();
 693                 result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
 694                                 new Object[] { component, artifactInfo });
 695         }
 696
 697
 698         @Test
 699         public void testUpdateGroupForHeat() throws Exception {
 700                 ArtifactsBusinessLogic testSubject;
 701                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 702                 ArtifactDefinition artAfterUpdate = null;
 703                 Component component = createResourceObject(true);
 704                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 705                 ActionStatus result;
 706
 707                 // default test
 708                 testSubject = createTestSubject();
 709                 result = Deencapsulation.invoke(testSubject, "updateGroupForHeat", new Object[] { artifactInfo,
 710                                 artifactInfo, component, componentType });
 711         }
 712
 713
 714         @Test
 715         public void testUpdateGroupForHeat_1() throws Exception {
 716                 ArtifactsBusinessLogic testSubject;
 717                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
 718                 Component component = createResourceObject(true);
 719                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 720                 ActionStatus result;
 721
 722                 // default test
 723                 testSubject = createTestSubject();
 724                 result = Deencapsulation.invoke(testSubject, "updateGroupForHeat",
 725                                 new Object[] { artifactInfo, artifactInfo, artifactInfo,
 726                                                 artifactInfo, component, componentType });
 727         }
 728
 729
 730
 731         @Test
 732         public void testHandleAuditing() throws Exception {
 733                 ArtifactsBusinessLogic testSubject;
 734                 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
 735                 Component component =  createResourceObject(true);
 736                 String componentId = "";
 737
 738                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
 739                 String prevArtifactUuid = "";
 740                 String currentArtifactUuid = "";
 741                 ResponseFormat responseFormat = new ResponseFormat();
 742                 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 743                 String resourceInstanceName = "";
 744
 745                 // test 1
 746                 testSubject = createTestSubject();
 747                 testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
 748                                 prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
 749         }
 750
 751         @Test
 752         public void testCreateArtifactAuditingFields() throws Exception {
 753                 ArtifactsBusinessLogic testSubject;
 754                 ArtifactDefinition artifactDefinition = null;
 755                 String prevArtifactUuid = "";
 756                 String currentArtifactUuid = "";
 757                 Map<AuditingFieldsKeysEnum, Object> result;
 758
 759                 // default test
 760                 testSubject = createTestSubject();
 761                 result = testSubject.createArtifactAuditingFields(artifactDefinition, prevArtifactUuid, currentArtifactUuid);
 762         }
 763
 764
 765
 766
 767
 768
 769
 770         @Test
 771         public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
 772                 ArtifactsBusinessLogic testSubject;
 773                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
 774                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 775                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 776                 ArtifactDefinition currentArtifactInfo = null;
 777
 778                 // default test
 779                 testSubject = createTestSubject();
 780                 Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
 781                                 new Object[] { operation, artifactInfo, artifactInfo });
 782         }
 783
 784
 785         @Test
 786         public void testFindArtifactOnParentComponent() throws Exception {
 787                 ArtifactsBusinessLogic testSubject;
 788                 Component component = createResourceObject(true);
 789                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 790                 String parentId = "";
 791                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
 792                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 793                 String artifactId = "";
 794                 Either<ArtifactDefinition, ResponseFormat> result;
 795
 796                 // default test
 797                 testSubject = createTestSubject();
 798                 result = Deencapsulation.invoke(testSubject, "findArtifactOnParentComponent", new Object[] { component,
 799                                 componentType, parentId, operation, artifactId });
 800         }
 801
 802
 803
 804
 805         @Test
 806         public void testValidateInformationalArtifact() throws Exception {
 807                 ArtifactsBusinessLogic testSubject;
 808                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 809                 Component component = createResourceObject(true);
 810                 Either<Boolean, ResponseFormat> result;
 811
 812                 // default test
 813                 testSubject = createTestSubject();
 814                 result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
 815                                 new Object[] { artifactInfo, component });
 816         }
 817
 818
 819
 820
 821
 822
 823         @Test
 824         public void testGetUpdatedGroups() throws Exception {
 825         ArtifactsBusinessLogic testSubject;String artifactId = "";
 826         ArtifactDefinition artifactInfo = buildArtifactPayload();
 827         List<GroupDefinition> groups = new ArrayList<>();
 828         List<GroupDataDefinition> result;
 829
 830         // test 1
 831         testSubject=createTestSubject();
 832         result=Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
 833         }
 834
 835
 836         @Test
 837         public void testGetUpdatedGroupInstances() throws Exception {
 838         ArtifactsBusinessLogic testSubject;String artifactId = "";
 839         ArtifactDefinition artifactInfo = buildArtifactPayload();
 840         List<GroupDefinition> groups = new ArrayList<>();
 841         List<GroupInstance> result;
 842
 843         // default test
 844         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
 845         }
 846
 847
 848
 849
 850         @Test
 851         public void testFindArtifact_1() throws Exception {
 852                 ArtifactsBusinessLogic testSubject;
 853                 String artifactId = "";
 854                 Component component =  createResourceObject(true);
 855                 String parentId = "";
 856                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 857                 Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> result;
 858
 859                 // default test
 860                 testSubject = createTestSubject();
 861                 result = Deencapsulation.invoke(testSubject, "findArtifact",
 862                                 new Object[] { artifactId, component, parentId, componentType });
 863         }
 864
 865
 866         @Test
 867         public void testFetchArtifactsFromInstance() throws Exception {
 868         ArtifactsBusinessLogic testSubject;String artifactId = "";
 869         Map<String,ArtifactDefinition> artifacts = new HashMap<>();
 870         ComponentInstance instance = new ComponentInstance();
 871
 872
 873         // default test
 874         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
 875         }
 876
 877
 878
 879
 880         @Test
 881         public void testGenerateCustomizationUUIDOnInstance() throws Exception {
 882                 ArtifactsBusinessLogic testSubject;
 883                 String componentId = "";
 884                 String instanceId = "";
 885                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 886                 StorageOperationStatus result;
 887
 888                 // default test
 889                 testSubject = createTestSubject();
 890                 result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
 891                                 new Object[] { componentId, instanceId, componentType });
 892         }
 893
 894
 895
 896         @Test
 897         public void testFindComponentInstance() throws Exception {
 898                 ArtifactsBusinessLogic testSubject;
 899                 String componentInstanceId = "";
 900                 Component component =  createResourceObject(true);;
 901                 ComponentInstance result;
 902
 903                 // default test
 904                 testSubject = createTestSubject();
 905                 result = Deencapsulation.invoke(testSubject, "findComponentInstance",
 906                                 new Object[] { componentInstanceId, component });
 907         }
 908
 909
 910         @Test
 911         public void testValidateDeploymentArtifactConf() throws Exception {
 912         ArtifactsBusinessLogic testSubject;ArtifactDefinition artifactInfo =  buildArtifactPayload();
 913         Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
 914         ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
 915         Map<String,ArtifactTypeConfig> resourceDeploymentArtifacts = new HashMap<>();
 916
 917
 918         // test 1
 919         testSubject=createTestSubject();
 920         Deencapsulation.invoke(testSubject, "validateDeploymentArtifactConf", new Object[]{artifactInfo, responseWrapper, artifactType, resourceDeploymentArtifacts});
 921         }
 922
 923
 924         @Test
 925         public void testFillDeploymentArtifactTypeConf() throws Exception {
 926                 ArtifactsBusinessLogic testSubject;
 927                 NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
 928                 Map<String, ArtifactTypeConfig> result;
 929
 930                 // default test
 931                 testSubject = createTestSubject();
 932                 result = Deencapsulation.invoke(testSubject, "fillDeploymentArtifactTypeConf",
 933                                 new Object[] { parentType });
 934         }
 935
 936
 937         @Test
 938         public void testValidateArtifactTypeExists() throws Exception {
 939                 ArtifactsBusinessLogic testSubject;
 940                 Wrapper<ResponseFormat> responseWrapper = null;
 941                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 942
 943                 // default test
 944                 testSubject = createTestSubject();
 945                 testSubject.validateArtifactTypeExists(responseWrapper, artifactInfo);
 946         }
 947
 948
 949         @Test
 950         public void testGetDeploymentArtifactTypeConfig() throws Exception {
 951                 ArtifactsBusinessLogic testSubject;
 952                 NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
 953                 ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
 954                 ArtifactTypeConfig result;
 955
 956                 // default test
 957                 testSubject = createTestSubject();
 958                 result = Deencapsulation.invoke(testSubject, "getDeploymentArtifactTypeConfig",
 959                                 new Object[] { parentType,artifactType });
 960         }
 961
 962
 963
 964
 965         @Test
 966         public void testValidateHeatEnvDeploymentArtifact() throws Exception {
 967                 ArtifactsBusinessLogic testSubject;
 968                 Component component = createResourceObject(true);
 969                 String parentId = "";
 970                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 971                 NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
 972                 Either<Boolean, ResponseFormat> result;
 973
 974                 // default test
 975                 testSubject = createTestSubject();
 976                 result = Deencapsulation.invoke(testSubject, "validateHeatEnvDeploymentArtifact",
 977                                 new Object[] { component, parentId, artifactInfo, parentType });
 978         }
 979
 980
 981         @Test
 982         public void testFillArtifactPayloadValidation() throws Exception {
 983                 ArtifactsBusinessLogic testSubject;
 984                 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 985                 Wrapper<byte[]> payloadWrapper = new Wrapper<>();;
 986                 ArtifactDefinition artifactDefinition = buildArtifactPayload();
 987
 988                 // default test
 989                 testSubject = createTestSubject();
 990                 testSubject.fillArtifactPayloadValidation(errorWrapper, payloadWrapper, artifactDefinition);
 991         }
 992
 993
 994
 995
 996
 997
 998
 999         @Test
1000         public void testValidateValidYaml() throws Exception {
1001         ArtifactsBusinessLogic testSubject;Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1002         ArtifactDefinition artifactInfo =  buildArtifactPayload();
1003
1004
1005         // default test
1006         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "validateValidYaml", new Object[]{errorWrapper, artifactInfo});
1007         }
1008
1009
1010         @Test
1011         public void testIsValidXml() throws Exception {
1012                 ArtifactsBusinessLogic testSubject;
1013                 byte[] xmlToParse = new byte[] { ' ' };
1014                 boolean result;
1015
1016                 // default test
1017                 testSubject = createTestSubject();
1018                 result = Deencapsulation.invoke(testSubject, "isValidXml", new Object[] { xmlToParse });
1019         }
1020
1021
1022
1023
1024
1025         @Test
1026         public void testIsValidJson() throws Exception {
1027                 ArtifactsBusinessLogic testSubject;
1028                 byte[] jsonToParse = new byte[] { ' ' };
1029                 boolean result;
1030
1031                 // default test
1032                 testSubject = createTestSubject();
1033                 result = Deencapsulation.invoke(testSubject, "isValidJson", new Object[] { jsonToParse });
1034         }
1035
1036
1037         @Test
1038         public void testValidateSingleDeploymentArtifactName() throws Exception {
1039         ArtifactsBusinessLogic testSubject;Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1040         String artifactName = "";
1041         Component component = createResourceObject(true);
1042         NodeTypeEnum parentType = null;
1043
1044
1045         // default test
1046         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "validateSingleDeploymentArtifactName", new Object[]{errorWrapper, artifactName, component, NodeTypeEnum.class});
1047         }
1048
1049
1050
1051         @Test
1052         public void testValidateHeatDeploymentArtifact() throws Exception {
1053                 ArtifactsBusinessLogic testSubject;
1054                 boolean isCreate = false;
1055                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1056                 ArtifactDefinition currentArtifact = null;
1057                 Either<Boolean, ResponseFormat> result;
1058
1059                 // default test
1060                 testSubject = createTestSubject();
1061                 result = Deencapsulation.invoke(testSubject, "validateHeatDeploymentArtifact",
1062                                 new Object[] { isCreate, artifactInfo, artifactInfo });
1063         }
1064
1065
1066         @Test
1067         public void testValidateResourceType() throws Exception {
1068         ArtifactsBusinessLogic testSubject;
1069         ResourceTypeEnum resourceType = ResourceTypeEnum.VF;
1070         ArtifactDefinition artifactInfo =  buildArtifactPayload();
1071         List<String> typeList = new ArrayList<>();
1072         Either<Boolean,ResponseFormat> result;
1073
1074         // test 1
1075         testSubject=createTestSubject();
1076         result=Deencapsulation.invoke(testSubject, "validateResourceType", new Object[]{resourceType, artifactInfo, typeList});
1077         }
1078
1079
1080         @Test
1081         public void testValidateAndConvertHeatParamers() throws Exception {
1082                 ArtifactsBusinessLogic testSubject;
1083                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1084                 String artifactType = "";
1085                 Either<ArtifactDefinition, ResponseFormat> result;
1086
1087                 // default test
1088                 testSubject = createTestSubject();
1089                 result = Deencapsulation.invoke(testSubject, "validateAndConvertHeatParamers",
1090                                 new Object[] { artifactInfo, artifactType });
1091         }
1092
1093
1094         @Test
1095         public void testGetDeploymentArtifacts() throws Exception {
1096                 ArtifactsBusinessLogic testSubject;
1097                 Component component = createResourceObject(true);
1098                 NodeTypeEnum parentType = null;
1099                 String ciId = "";
1100                 List<ArtifactDefinition> result;
1101
1102                 // default test
1103                 testSubject = createTestSubject();
1104                 result = testSubject.getDeploymentArtifacts(component, parentType, ciId);
1105         }
1106
1107
1108
1109         @Test
1110         public void testValidateFirstUpdateHasPayload() throws Exception {
1111                 ArtifactsBusinessLogic testSubject;
1112                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1113                 ArtifactDefinition currentArtifact = null;
1114                 Either<Boolean, ResponseFormat> result;
1115
1116                 // default test
1117                 testSubject = createTestSubject();
1118                 result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1119                                 new Object[] { artifactInfo, artifactInfo });
1120         }
1121
1122
1123         @Test
1124         public void testValidateAndSetArtifactname() throws Exception {
1125                 ArtifactsBusinessLogic testSubject;
1126                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1127                 Either<Boolean, ResponseFormat> result;
1128
1129                 // default test
1130                 testSubject = createTestSubject();
1131                 result = Deencapsulation.invoke(testSubject, "validateAndSetArtifactname",
1132                                 new Object[] { artifactInfo });
1133         }
1134
1135
1136         @Test
1137         public void testValidateArtifactTypeNotChanged() throws Exception {
1138                 ArtifactsBusinessLogic testSubject;
1139                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1140                 ArtifactDefinition currentArtifact = null;
1141                 Either<Boolean, ResponseFormat> result;
1142
1143                 // default test
1144                 testSubject = createTestSubject();
1145                 result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1146                                 new Object[] { artifactInfo, artifactInfo });
1147         }
1148
1149
1150         @Test
1151         public void testValidateOrSetArtifactGroupType() throws Exception {
1152                 ArtifactsBusinessLogic testSubject;
1153                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1154                 ArtifactDefinition currentArtifact = null;
1155                 Either<ArtifactDefinition, ResponseFormat> result;
1156
1157                 // default test
1158                 testSubject = createTestSubject();
1159                 result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1160                                 new Object[] { artifactInfo, artifactInfo });
1161         }
1162
1163
1164         @Test
1165         public void testCheckAndSetUnUpdatableFields() throws Exception {
1166                 ArtifactsBusinessLogic testSubject;
1167
1168                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1169                 ArtifactDefinition currentArtifact = null;
1170                 ArtifactGroupTypeEnum type = null;
1171
1172                 // test 1
1173                 testSubject = createTestSubject();
1174                 type = null;
1175                 Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", new Object[] { user,
1176                                 artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class });
1177         }
1178
1179
1180         @Test
1181         public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1182         ArtifactsBusinessLogic testSubject;
1183         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1184         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1185
1186
1187         // default test
1188         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1189         }
1190
1191
1192         @Test
1193         public void testGetMapOfParameters() throws Exception {
1194         ArtifactsBusinessLogic testSubject;
1195         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1196         Map<String,HeatParameterDefinition> result;
1197
1198         // default test
1199         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1200         }
1201
1202
1203
1204
1205
1206
1207         @Test
1208         public void testHandlePayload() throws Exception {
1209                 ArtifactsBusinessLogic testSubject;
1210                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1211                 boolean isArtifactMetadataUpdate = false;
1212                 Either<byte[], ResponseFormat> result;
1213
1214                 // default test
1215                 testSubject = createTestSubject();
1216                 result = Deencapsulation.invoke(testSubject, "handlePayload",
1217                                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1218         }
1219
1220
1221
1222
1223
1224         @Test
1225         public void testValidateYmlPayload() throws Exception {
1226                 ArtifactsBusinessLogic testSubject;
1227                 byte[] decodedPayload = new byte[] { ' ' };
1228                 String artifactType = "";
1229                 Either<Boolean, ResponseFormat> result;
1230
1231                 // default test
1232                 testSubject = createTestSubject();
1233                 result = Deencapsulation.invoke(testSubject, "validateYmlPayload",
1234                                 new Object[] { decodedPayload, artifactType });
1235         }
1236
1237
1238         @Test
1239         public void testValidateXmlPayload() throws Exception {
1240                 ArtifactsBusinessLogic testSubject;
1241                 byte[] payload = new byte[] { ' ' };
1242                 String artifactType = "";
1243                 Either<Boolean, ResponseFormat> result;
1244
1245                 // default test
1246                 testSubject = createTestSubject();
1247                 result = Deencapsulation.invoke(testSubject, "validateXmlPayload", new Object[] { payload, artifactType });
1248         }
1249
1250
1251         @Test
1252         public void testValidateJsonPayload() throws Exception {
1253                 ArtifactsBusinessLogic testSubject;
1254                 byte[] payload = new byte[] { ' ' };
1255                 String type = "";
1256                 Either<Boolean, ResponseFormat> result;
1257
1258                 // default test
1259                 testSubject = createTestSubject();
1260                 result = Deencapsulation.invoke(testSubject, "validateJsonPayload", new Object[] { payload, type });
1261         }
1262
1263
1264
1265
1266
1267
1268         @Test
1269         public void testValidateUserRole() throws Exception {
1270                 ArtifactsBusinessLogic testSubject;
1271
1272                 AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
1273                 String componentId = "";
1274                 String artifactId = "";
1275                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1276                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
1277                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1278                 Either<Boolean, ResponseFormat> result;
1279
1280                 // default test
1281                 testSubject = createTestSubject();
1282                 result = Deencapsulation.invoke(testSubject, "validateUserRole",
1283                                 new Object[] { user, auditingAction, componentId, artifactId, componentType,
1284                                                 operation });
1285         }
1286
1287         @Test
1288         public void testDetectAuditingType() throws Exception {
1289                 ArtifactsBusinessLogic testSubject;
1290                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
1291                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1292                 String origMd5 = "";
1293                 AuditingActionEnum result;
1294
1295                 // default test
1296                 testSubject = createTestSubject();
1297                 result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1298                                 new Object[] { operation, origMd5 });
1299         }
1300
1301
1302
1303
1304         @Test
1305         public void testCreateEsArtifactData() throws Exception {
1306                 ArtifactsBusinessLogic testSubject;
1307                 ArtifactDataDefinition artifactInfo = buildArtifactPayload();;;
1308                 byte[] artifactPayload = new byte[] { ' ' };
1309                 ESArtifactData result;
1310
1311                 // default test
1312                 testSubject = createTestSubject();
1313                 result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1314         }
1315
1316
1317
1318
1319
1320         @Test
1321         public void testIsArtifactMetadataUpdate() throws Exception {
1322                 ArtifactsBusinessLogic testSubject;
1323                 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1324                 boolean result;
1325
1326                 // default test
1327                 testSubject = createTestSubject();
1328                 result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1329                                 new Object[] { auditingActionEnum });
1330         }
1331
1332
1333         @Test
1334         public void testIsDeploymentArtifact() throws Exception {
1335                 ArtifactsBusinessLogic testSubject;
1336                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1337                 boolean result;
1338
1339                 // default test
1340                 testSubject = createTestSubject();
1341                 result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[] { artifactInfo });
1342         }
1343
1344
1345
1346
1347
1348         @Test
1349         public void testSetArtifactPlaceholderCommonFields() throws Exception {
1350                 ArtifactsBusinessLogic testSubject;
1351                 String resourceId = "";
1352
1353                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1354
1355                 // test 1
1356                 testSubject = createTestSubject();
1357                 Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1358                                 new Object[] { resourceId, user, artifactInfo });
1359
1360         }
1361
1362
1363         @Test
1364         public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1365                 ArtifactsBusinessLogic testSubject;
1366                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
1367                 String payloadStr = "";
1368                 Either<ESArtifactData, ResponseFormat> result;
1369
1370                 // default test
1371                 testSubject = createTestSubject();
1372                 result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1373                                 new Object[] { artifactDefinition, payloadStr });
1374         }
1375
1376
1377
1378
1379
1380
1381
1382
1383         @Test
1384         public void testUpdateArtifactOnGroupInstance() throws Exception {
1385                 ArtifactsBusinessLogic testSubject;
1386                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1387                 Component component =  createResourceObject(true);
1388                 String instanceId = "";
1389                 String prevUUID = "";
1390                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1391                 Either<ArtifactDefinition, ResponseFormat> result;
1392
1393                 // test 1
1394                 testSubject = createTestSubject();
1395                 prevUUID = "";
1396                 result = Deencapsulation.invoke(testSubject, "updateArtifactOnGroupInstance",
1397                                 new Object[] { componentType, component, instanceId, prevUUID, artifactInfo,
1398                                                 artifactInfo });
1399         }
1400
1401
1402         @Test
1403         public void testGenerateHeatEnvPayload() throws Exception {
1404                 ArtifactsBusinessLogic testSubject;
1405                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
1406                 String result;
1407
1408                 // default test
1409                 testSubject = createTestSubject();
1410                 result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1411                                 new Object[] { artifactDefinition });
1412         }
1413
1414
1415
1416
1417
1418
1419         @Test
1420         public void testBuildJsonForUpdateArtifact() throws Exception {
1421                 ArtifactsBusinessLogic testSubject;
1422                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1423                 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1424                 List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1425                 Map<String, Object> result;
1426
1427                 // default test
1428                 testSubject = createTestSubject();
1429                 result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1430         }
1431
1432
1433         @Test
1434         public void testBuildJsonForUpdateArtifact_1() throws Exception {
1435                 ArtifactsBusinessLogic testSubject;
1436                 String artifactId = "";
1437                 String artifactName = "";
1438                 String artifactType = "";
1439                 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1440                 String label = "";
1441                 String displayName = "";
1442                 String description = "";
1443                 byte[] artifactContent = new byte[] { ' ' };
1444                 List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1445                 List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1446                 Map<String, Object> result;
1447
1448                 // test 1
1449                 testSubject = createTestSubject();
1450                 artifactId = "";
1451                 result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1452                                 label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1453         }
1454
1455
1456
1457
1458
1459
1460         @Test
1461         public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1462         ArtifactsBusinessLogic testSubject;
1463         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1464         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1465
1466
1467         // default test
1468         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1469         }
1470
1471
1472
1473         @Test
1474         public void testExtractArtifactDefinition() throws Exception {
1475                 ArtifactsBusinessLogic testSubject;
1476                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;
1477                 Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1478                 ArtifactDefinition result;
1479
1480                 // default test
1481                 testSubject = createTestSubject();
1482                 result = testSubject.extractArtifactDefinition(eitherArtifact);
1483         }
1484
1485
1486
1487
1488         @Test
1489         public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1490                 ArtifactsBusinessLogic testSubject;
1491                 ArtifactDefinition artifact = null;
1492                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1493
1494                 // default test
1495                 testSubject = createTestSubject();
1496                 Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1497                                 new Object[] { artifactInfo, artifactInfo });
1498         }
1499
1500
1501         @Test
1502         public void testBuildHeatEnvFileName() throws Exception {
1503         ArtifactsBusinessLogic testSubject;
1504         ArtifactDefinition heatArtifact = null;
1505         ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1506         Map<String,Object> placeHolderData = new HashMap<>();
1507
1508
1509         // default test
1510         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{artifactInfo, artifactInfo, placeHolderData});
1511         }
1512
1513
1514         @Test
1515         public void testHandleEnvArtifactVersion() throws Exception {
1516         ArtifactsBusinessLogic testSubject;
1517         ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1518         Map<String,String> existingEnvVersions = new HashMap<>();
1519
1520
1521         // test 1
1522         testSubject=createTestSubject();
1523         Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", new Object[]{artifactInfo, existingEnvVersions});
1524         }
1525
1526
1527         @Test
1528         public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1529                 ArtifactsBusinessLogic testSubject;
1530                 List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();;
1531                 Resource component = createResourceObject(true);;
1532
1533                 List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();;
1534                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
1535                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1536                 boolean shouldLock = false;
1537                 boolean inTransaction = false;
1538                 Either<List<ArtifactDefinition>, ResponseFormat> result;
1539
1540                 // default test
1541                 testSubject = createTestSubject();
1542                 result = testSubject.handleArtifactsRequestForInnerVfcComponent(artifactsToHandle, component, user,
1543                                 vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1544         }
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556         @Test
1557         public void testUpdateAuditParametersWithArtifactDefinition() throws Exception {
1558         ArtifactsBusinessLogic testSubject;
1559         Map<AuditingFieldsKeysEnum,Object> additionalParams = new HashMap<>();
1560         ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1561
1562
1563         // test 1
1564         testSubject=createTestSubject();
1565         Deencapsulation.invoke(testSubject, "updateAuditParametersWithArtifactDefinition", new Object[]{additionalParams, artifactInfo});
1566         }
1567
1568
1569         @Test
1570         public void testSetNodeTemplateOperation() throws Exception {
1571                 ArtifactsBusinessLogic testSubject;
1572                 NodeTemplateOperation nodeTemplateOperation = null;
1573
1574                 // default test
1575                 testSubject = createTestSubject();
1576                 Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", new Object[] { NodeTemplateOperation.class });
1577         }
1578 }