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