2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.components.impl;
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;
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;
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;
115 public class ArtifactsBusinessLogicTest {
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";
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);
132 TitanDao mockTitanDao = Mockito.mock(TitanDao.class);
134 static ConfigurationSource configurationSource = new FSConfigurationSource(
135 ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
136 static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
139 private static ArtifactsBusinessLogic artifactBL;
141 private static User user = null;
142 private static Resource resourceResponse = null;
143 private static ResponseFormatManager responseManager = null;
146 private UserBusinessLogic userBusinessLogic;
148 private ArtifactOperation artifactOperation;
150 public ComponentsUtils componentsUtils;
152 private IInterfaceLifecycleOperation lifecycleOperation;
154 private IUserAdminOperation userOperation;
156 private IElementOperation elementOperation;
158 private ArtifactCassandraDao artifactCassandraDao;
160 public ToscaOperationFacade toscaOperationFacade;
162 private NodeTemplateOperation nodeTemplateOperation;
164 private ArtifactsOperations artifactsOperations;
166 private IGraphLockOperation graphLockOperation;
170 public static final Resource resource = Mockito.mock(Resource.class);
171 private Gson gson = new GsonBuilder().setPrettyPrinting().create();
173 private static List<ArtifactType> getAllTypes() {
174 List<ArtifactType> artifactTypes = new ArrayList<ArtifactType>();
175 List<String> artifactTypesList = ConfigurationManager.getConfigurationManager().getConfiguration()
177 for (String artifactType : artifactTypesList) {
178 ArtifactType artifactT = new ArtifactType();
179 artifactT.setName(artifactType);
180 artifactTypes.add(artifactT);
182 return artifactTypes;
186 public void initMocks() {
187 MockitoAnnotations.initMocks(this);
188 Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
189 .right(StorageOperationStatus.NOT_FOUND);
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);
198 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
199 .right(StorageOperationStatus.NOT_FOUND);
200 when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
201 .thenReturn(notFoundInterfaces);
203 Either<User, ActionStatus> getUserResult = Either.left(USER);
205 when(userOperation.getUserData("jh0003", false)).thenReturn(getUserResult);
207 Either<List<ArtifactType>, ActionStatus> getType = Either.left(getAllTypes());
208 when(elementOperation.getAllArtifactTypes()).thenReturn(getType);
210 when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
212 // User data and management
214 user.setUserId("jh0003");
215 user.setFirstName("Jimmi");
216 user.setLastName("Hendrix");
217 user.setRole(Role.ADMIN.name());
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);
229 Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
230 .right(StorageOperationStatus.BAD_REQUEST);
231 when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
232 .thenReturn(resourceStorageOperationStatusEither);
236 public void testValidJson() {
237 ArtifactDefinition ad = createArtifactDef();
239 String jsonArtifact = "";
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);
247 jsonArtifact = mapper.writeValueAsString(ad);
248 } catch (IOException e) {
249 // TODO Auto-generated catch block
253 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
254 ArtifactDefinition.class);
255 assertEquals(ad, afterConvert);
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);
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>();
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");
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);
300 public void testInvalidStringGroupType() {
301 ArtifactDefinition ad = new ArtifactDefinition();
302 ad.setArtifactName("artifact1");
303 ad.setCreationDate(System.currentTimeMillis());
304 ad.setMandatory(false);
307 JsonElement jsonArtifact = gson.toJsonTree(ad);
308 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
310 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
311 ArtifactDefinition.class);
312 assertNull(afterConvert);
316 public void testInvalidNumberGroupType() {
317 ArtifactDefinition ad = new ArtifactDefinition();
318 ad.setArtifactName("artifact1");
319 ad.setCreationDate(System.currentTimeMillis());
320 ad.setMandatory(false);
323 JsonElement jsonArtifact = gson.toJsonTree(ad);
324 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
326 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
327 ArtifactDefinition.class);
328 assertNull(afterConvert);
332 public void testInvalidGroupTypeWithSpace() {
333 ArtifactDefinition ad = new ArtifactDefinition();
334 ad.setArtifactName("artifact1");
335 ad.setCreationDate(System.currentTimeMillis());
336 ad.setMandatory(false);
339 JsonElement jsonArtifact = gson.toJsonTree(ad);
340 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
342 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
343 ArtifactDefinition.class);
344 assertNull(afterConvert);
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);
355 JsonElement jsonArtifact = gson.toJsonTree(ad);
356 jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
358 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
359 ArtifactDefinition.class);
360 assertNull(afterConvert);
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()));
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);
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);
396 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
397 toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
398 service.setToscaArtifacts(toscaArtifacts);
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
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);
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();
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());
435 public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
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();
443 Resource component = new Resource();
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()));
450 Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
451 heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
452 Collections.emptyMap());
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);
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);
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);
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);
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();
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);
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;
523 private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
524 assertEquals(heatEnvParam.getDefaultValue(), heatYamlParam.getCurrentValue());
525 assertNull(heatEnvParam.getCurrentValue());
528 private ArtifactsBusinessLogic createTestSubject() {
529 return new ArtifactsBusinessLogic();
533 public void testBuildJsonStringForCsarVfcArtifact() throws Exception {
534 ArtifactsBusinessLogic testSubject;
535 ArtifactDefinition artifact = new ArtifactDefinition();
539 testSubject = createTestSubject();
540 result = Deencapsulation.invoke(testSubject, "buildJsonStringForCsarVfcArtifact", new Object[] { artifact });
544 public void testCheckArtifactInComponent() throws Exception {
545 ArtifactsBusinessLogic testSubject;
546 Component component = new Resource();
547 String artifactId = "";
551 testSubject = createTestSubject();
552 result = Deencapsulation.invoke(testSubject, "checkArtifactInComponent",
553 new Object[] { component, artifactId });
559 public void testCheckCreateFields() throws Exception {
560 ArtifactsBusinessLogic testSubject;
562 ArtifactDefinition artifactInfo = buildArtifactPayload();
563 ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
566 testSubject = createTestSubject();
567 Deencapsulation.invoke(testSubject, "checkCreateFields", new Object[] { user, artifactInfo, type });
572 public void testComposeArtifactId() throws Exception {
573 ArtifactsBusinessLogic testSubject;
574 String resourceId = "";
575 String artifactId = "";
576 ArtifactDefinition artifactInfo = buildArtifactPayload();
578 String interfaceName = "";
579 String operationName = "";
583 testSubject = createTestSubject();
584 result = Deencapsulation.invoke(testSubject, "composeArtifactId",
585 new Object[] { resourceId, artifactId, artifactInfo, interfaceName, operationName });
589 public void testConvertParentType() throws Exception {
590 ArtifactsBusinessLogic testSubject;
591 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
595 testSubject = createTestSubject();
596 result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[] { componentType });
600 public void testConvertToOperation() throws Exception {
601 ArtifactsBusinessLogic testSubject;
602 ArtifactDefinition artifactInfo = buildArtifactPayload();
603 String operationName = "";
607 testSubject = createTestSubject();
608 result = Deencapsulation.invoke(testSubject, "convertToOperation",
609 new Object[] { artifactInfo, operationName });
613 public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
614 ArtifactsBusinessLogic testSubject;
615 String operationName = "";
616 String artifactName = "";
620 testSubject = createTestSubject();
621 result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
622 new Object[] { operationName, artifactName });
626 public void testFetchArtifactsFromComponent() throws Exception {
627 ArtifactsBusinessLogic testSubject;
628 String artifactId = "";
629 Component component = createResourceObject(true);
630 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
633 testSubject = createTestSubject();
634 Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
635 new Object[] { artifactId, component, artifacts });
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;
655 Component component = createResourceObject(true);
656 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
657 boolean shouldLock = false;
658 boolean inTransaction = false;
659 ArtifactDefinition result;
662 testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "validateArtifact", new Object[]{componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, component, errorWrapper, shouldLock, inTransaction});
667 public void testHandleHeatEnvDownload() throws Exception {
668 ArtifactsBusinessLogic testSubject;String componentId = "";
669 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
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;
680 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "handleHeatEnvDownload", new Object[]{componentId, componentType, user, component, validateArtifact, errorWrapper, shouldLock, inTransaction});
685 public void testArtifactGenerationRequired() throws Exception {
686 ArtifactsBusinessLogic testSubject;
687 Component component = createResourceObject(true);
688 ArtifactDefinition artifactInfo = buildArtifactPayload();
692 testSubject = createTestSubject();
693 result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
694 new Object[] { component, artifactInfo });
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;
708 testSubject = createTestSubject();
709 result = Deencapsulation.invoke(testSubject, "updateGroupForHeat", new Object[] { artifactInfo,
710 artifactInfo, component, componentType });
715 public void testUpdateGroupForHeat_1() throws Exception {
716 ArtifactsBusinessLogic testSubject;
717 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
718 Component component = createResourceObject(true);
719 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
723 testSubject = createTestSubject();
724 result = Deencapsulation.invoke(testSubject, "updateGroupForHeat",
725 new Object[] { artifactInfo, artifactInfo, artifactInfo,
726 artifactInfo, component, componentType });
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 = "";
738 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
739 String prevArtifactUuid = "";
740 String currentArtifactUuid = "";
741 ResponseFormat responseFormat = new ResponseFormat();
742 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
743 String resourceInstanceName = "";
746 testSubject = createTestSubject();
747 testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
748 prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
752 public void testCreateArtifactAuditingFields() throws Exception {
753 ArtifactsBusinessLogic testSubject;
754 ArtifactDefinition artifactDefinition = null;
755 String prevArtifactUuid = "";
756 String currentArtifactUuid = "";
757 Map<AuditingFieldsKeysEnum, Object> result;
760 testSubject = createTestSubject();
761 result = testSubject.createArtifactAuditingFields(artifactDefinition, prevArtifactUuid, currentArtifactUuid);
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;
779 testSubject = createTestSubject();
780 Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
781 new Object[] { operation, artifactInfo, artifactInfo });
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;
797 testSubject = createTestSubject();
798 result = Deencapsulation.invoke(testSubject, "findArtifactOnParentComponent", new Object[] { component,
799 componentType, parentId, operation, artifactId });
806 public void testValidateInformationalArtifact() throws Exception {
807 ArtifactsBusinessLogic testSubject;
808 ArtifactDefinition artifactInfo = buildArtifactPayload();
809 Component component = createResourceObject(true);
810 Either<Boolean, ResponseFormat> result;
813 testSubject = createTestSubject();
814 result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
815 new Object[] { artifactInfo, component });
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;
831 testSubject=createTestSubject();
832 result=Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
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;
844 testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
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;
860 testSubject = createTestSubject();
861 result = Deencapsulation.invoke(testSubject, "findArtifact",
862 new Object[] { artifactId, component, parentId, componentType });
867 public void testFetchArtifactsFromInstance() throws Exception {
868 ArtifactsBusinessLogic testSubject;String artifactId = "";
869 Map<String,ArtifactDefinition> artifacts = new HashMap<>();
870 ComponentInstance instance = new ComponentInstance();
874 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
881 public void testGenerateCustomizationUUIDOnInstance() throws Exception {
882 ArtifactsBusinessLogic testSubject;
883 String componentId = "";
884 String instanceId = "";
885 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
886 StorageOperationStatus result;
889 testSubject = createTestSubject();
890 result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
891 new Object[] { componentId, instanceId, componentType });
897 public void testFindComponentInstance() throws Exception {
898 ArtifactsBusinessLogic testSubject;
899 String componentInstanceId = "";
900 Component component = createResourceObject(true);;
901 ComponentInstance result;
904 testSubject = createTestSubject();
905 result = Deencapsulation.invoke(testSubject, "findComponentInstance",
906 new Object[] { componentInstanceId, component });
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<>();
919 testSubject=createTestSubject();
920 Deencapsulation.invoke(testSubject, "validateDeploymentArtifactConf", new Object[]{artifactInfo, responseWrapper, artifactType, resourceDeploymentArtifacts});
925 public void testFillDeploymentArtifactTypeConf() throws Exception {
926 ArtifactsBusinessLogic testSubject;
927 NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
928 Map<String, ArtifactTypeConfig> result;
931 testSubject = createTestSubject();
932 result = Deencapsulation.invoke(testSubject, "fillDeploymentArtifactTypeConf",
933 new Object[] { parentType });
938 public void testValidateArtifactTypeExists() throws Exception {
939 ArtifactsBusinessLogic testSubject;
940 Wrapper<ResponseFormat> responseWrapper = null;
941 ArtifactDefinition artifactInfo = buildArtifactPayload();
944 testSubject = createTestSubject();
945 testSubject.validateArtifactTypeExists(responseWrapper, artifactInfo);
950 public void testGetDeploymentArtifactTypeConfig() throws Exception {
951 ArtifactsBusinessLogic testSubject;
952 NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
953 ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
954 ArtifactTypeConfig result;
957 testSubject = createTestSubject();
958 result = Deencapsulation.invoke(testSubject, "getDeploymentArtifactTypeConfig",
959 new Object[] { parentType,artifactType });
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;
975 testSubject = createTestSubject();
976 result = Deencapsulation.invoke(testSubject, "validateHeatEnvDeploymentArtifact",
977 new Object[] { component, parentId, artifactInfo, parentType });
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();
989 testSubject = createTestSubject();
990 testSubject.fillArtifactPayloadValidation(errorWrapper, payloadWrapper, artifactDefinition);
1000 public void testValidateValidYaml() throws Exception {
1001 ArtifactsBusinessLogic testSubject;Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1002 ArtifactDefinition artifactInfo = buildArtifactPayload();
1006 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "validateValidYaml", new Object[]{errorWrapper, artifactInfo});
1011 public void testIsValidXml() throws Exception {
1012 ArtifactsBusinessLogic testSubject;
1013 byte[] xmlToParse = new byte[] { ' ' };
1017 testSubject = createTestSubject();
1018 result = Deencapsulation.invoke(testSubject, "isValidXml", new Object[] { xmlToParse });
1026 public void testIsValidJson() throws Exception {
1027 ArtifactsBusinessLogic testSubject;
1028 byte[] jsonToParse = new byte[] { ' ' };
1032 testSubject = createTestSubject();
1033 result = Deencapsulation.invoke(testSubject, "isValidJson", new Object[] { jsonToParse });
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;
1046 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "validateSingleDeploymentArtifactName", new Object[]{errorWrapper, artifactName, component, NodeTypeEnum.class});
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;
1060 testSubject = createTestSubject();
1061 result = Deencapsulation.invoke(testSubject, "validateHeatDeploymentArtifact",
1062 new Object[] { isCreate, artifactInfo, artifactInfo });
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;
1075 testSubject=createTestSubject();
1076 result=Deencapsulation.invoke(testSubject, "validateResourceType", new Object[]{resourceType, artifactInfo, typeList});
1081 public void testValidateAndConvertHeatParamers() throws Exception {
1082 ArtifactsBusinessLogic testSubject;
1083 ArtifactDefinition artifactInfo = buildArtifactPayload();
1084 String artifactType = "";
1085 Either<ArtifactDefinition, ResponseFormat> result;
1088 testSubject = createTestSubject();
1089 result = Deencapsulation.invoke(testSubject, "validateAndConvertHeatParamers",
1090 new Object[] { artifactInfo, artifactType });
1095 public void testGetDeploymentArtifacts() throws Exception {
1096 ArtifactsBusinessLogic testSubject;
1097 Component component = createResourceObject(true);
1098 NodeTypeEnum parentType = null;
1100 List<ArtifactDefinition> result;
1103 testSubject = createTestSubject();
1104 result = testSubject.getDeploymentArtifacts(component, parentType, ciId);
1110 public void testValidateFirstUpdateHasPayload() throws Exception {
1111 ArtifactsBusinessLogic testSubject;
1112 ArtifactDefinition artifactInfo = buildArtifactPayload();
1113 ArtifactDefinition currentArtifact = null;
1114 Either<Boolean, ResponseFormat> result;
1117 testSubject = createTestSubject();
1118 result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1119 new Object[] { artifactInfo, artifactInfo });
1124 public void testValidateAndSetArtifactname() throws Exception {
1125 ArtifactsBusinessLogic testSubject;
1126 ArtifactDefinition artifactInfo = buildArtifactPayload();
1127 Either<Boolean, ResponseFormat> result;
1130 testSubject = createTestSubject();
1131 result = Deencapsulation.invoke(testSubject, "validateAndSetArtifactname",
1132 new Object[] { artifactInfo });
1137 public void testValidateArtifactTypeNotChanged() throws Exception {
1138 ArtifactsBusinessLogic testSubject;
1139 ArtifactDefinition artifactInfo = buildArtifactPayload();
1140 ArtifactDefinition currentArtifact = null;
1141 Either<Boolean, ResponseFormat> result;
1144 testSubject = createTestSubject();
1145 result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1146 new Object[] { artifactInfo, artifactInfo });
1151 public void testValidateOrSetArtifactGroupType() throws Exception {
1152 ArtifactsBusinessLogic testSubject;
1153 ArtifactDefinition artifactInfo = buildArtifactPayload();
1154 ArtifactDefinition currentArtifact = null;
1155 Either<ArtifactDefinition, ResponseFormat> result;
1158 testSubject = createTestSubject();
1159 result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1160 new Object[] { artifactInfo, artifactInfo });
1165 public void testCheckAndSetUnUpdatableFields() throws Exception {
1166 ArtifactsBusinessLogic testSubject;
1168 ArtifactDefinition artifactInfo = buildArtifactPayload();
1169 ArtifactDefinition currentArtifact = null;
1170 ArtifactGroupTypeEnum type = null;
1173 testSubject = createTestSubject();
1175 Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", new Object[] { user,
1176 artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class });
1181 public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1182 ArtifactsBusinessLogic testSubject;
1183 List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1184 List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1188 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1193 public void testGetMapOfParameters() throws Exception {
1194 ArtifactsBusinessLogic testSubject;
1195 List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1196 Map<String,HeatParameterDefinition> result;
1199 testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1208 public void testHandlePayload() throws Exception {
1209 ArtifactsBusinessLogic testSubject;
1210 ArtifactDefinition artifactInfo = buildArtifactPayload();
1211 boolean isArtifactMetadataUpdate = false;
1212 Either<byte[], ResponseFormat> result;
1215 testSubject = createTestSubject();
1216 result = Deencapsulation.invoke(testSubject, "handlePayload",
1217 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1225 public void testValidateYmlPayload() throws Exception {
1226 ArtifactsBusinessLogic testSubject;
1227 byte[] decodedPayload = new byte[] { ' ' };
1228 String artifactType = "";
1229 Either<Boolean, ResponseFormat> result;
1232 testSubject = createTestSubject();
1233 result = Deencapsulation.invoke(testSubject, "validateYmlPayload",
1234 new Object[] { decodedPayload, artifactType });
1239 public void testValidateXmlPayload() throws Exception {
1240 ArtifactsBusinessLogic testSubject;
1241 byte[] payload = new byte[] { ' ' };
1242 String artifactType = "";
1243 Either<Boolean, ResponseFormat> result;
1246 testSubject = createTestSubject();
1247 result = Deencapsulation.invoke(testSubject, "validateXmlPayload", new Object[] { payload, artifactType });
1252 public void testValidateJsonPayload() throws Exception {
1253 ArtifactsBusinessLogic testSubject;
1254 byte[] payload = new byte[] { ' ' };
1256 Either<Boolean, ResponseFormat> result;
1259 testSubject = createTestSubject();
1260 result = Deencapsulation.invoke(testSubject, "validateJsonPayload", new Object[] { payload, type });
1269 public void testValidateUserRole() throws Exception {
1270 ArtifactsBusinessLogic testSubject;
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;
1281 testSubject = createTestSubject();
1282 result = Deencapsulation.invoke(testSubject, "validateUserRole",
1283 new Object[] { user, auditingAction, componentId, artifactId, componentType,
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;
1296 testSubject = createTestSubject();
1297 result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1298 new Object[] { operation, origMd5 });
1305 public void testCreateEsArtifactData() throws Exception {
1306 ArtifactsBusinessLogic testSubject;
1307 ArtifactDataDefinition artifactInfo = buildArtifactPayload();;;
1308 byte[] artifactPayload = new byte[] { ' ' };
1309 ESArtifactData result;
1312 testSubject = createTestSubject();
1313 result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1321 public void testIsArtifactMetadataUpdate() throws Exception {
1322 ArtifactsBusinessLogic testSubject;
1323 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1327 testSubject = createTestSubject();
1328 result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1329 new Object[] { auditingActionEnum });
1334 public void testIsDeploymentArtifact() throws Exception {
1335 ArtifactsBusinessLogic testSubject;
1336 ArtifactDefinition artifactInfo = buildArtifactPayload();
1340 testSubject = createTestSubject();
1341 result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[] { artifactInfo });
1349 public void testSetArtifactPlaceholderCommonFields() throws Exception {
1350 ArtifactsBusinessLogic testSubject;
1351 String resourceId = "";
1353 ArtifactDefinition artifactInfo = buildArtifactPayload();
1356 testSubject = createTestSubject();
1357 Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1358 new Object[] { resourceId, user, artifactInfo });
1364 public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1365 ArtifactsBusinessLogic testSubject;
1366 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
1367 String payloadStr = "";
1368 Either<ESArtifactData, ResponseFormat> result;
1371 testSubject = createTestSubject();
1372 result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1373 new Object[] { artifactDefinition, payloadStr });
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;
1394 testSubject = createTestSubject();
1396 result = Deencapsulation.invoke(testSubject, "updateArtifactOnGroupInstance",
1397 new Object[] { componentType, component, instanceId, prevUUID, artifactInfo,
1403 public void testGenerateHeatEnvPayload() throws Exception {
1404 ArtifactsBusinessLogic testSubject;
1405 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
1409 testSubject = createTestSubject();
1410 result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1411 new Object[] { artifactDefinition });
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;
1428 testSubject = createTestSubject();
1429 result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1434 public void testBuildJsonForUpdateArtifact_1() throws Exception {
1435 ArtifactsBusinessLogic testSubject;
1436 String artifactId = "";
1437 String artifactName = "";
1438 String artifactType = "";
1439 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
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;
1449 testSubject = createTestSubject();
1451 result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1452 label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1461 public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1462 ArtifactsBusinessLogic testSubject;
1463 List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1464 List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1468 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1474 public void testExtractArtifactDefinition() throws Exception {
1475 ArtifactsBusinessLogic testSubject;
1476 ArtifactDefinition artifactDefinition = buildArtifactPayload();;
1477 Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1478 ArtifactDefinition result;
1481 testSubject = createTestSubject();
1482 result = testSubject.extractArtifactDefinition(eitherArtifact);
1489 public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1490 ArtifactsBusinessLogic testSubject;
1491 ArtifactDefinition artifact = null;
1492 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1495 testSubject = createTestSubject();
1496 Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1497 new Object[] { artifactInfo, artifactInfo });
1502 public void testBuildHeatEnvFileName() throws Exception {
1503 ArtifactsBusinessLogic testSubject;
1504 ArtifactDefinition heatArtifact = null;
1505 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1506 Map<String,Object> placeHolderData = new HashMap<>();
1510 testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{artifactInfo, artifactInfo, placeHolderData});
1515 public void testHandleEnvArtifactVersion() throws Exception {
1516 ArtifactsBusinessLogic testSubject;
1517 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1518 Map<String,String> existingEnvVersions = new HashMap<>();
1522 testSubject=createTestSubject();
1523 Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", new Object[]{artifactInfo, existingEnvVersions});
1528 public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1529 ArtifactsBusinessLogic testSubject;
1530 List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();;
1531 Resource component = createResourceObject(true);;
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;
1541 testSubject = createTestSubject();
1542 result = testSubject.handleArtifactsRequestForInnerVfcComponent(artifactsToHandle, component, user,
1543 vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1557 public void testUpdateAuditParametersWithArtifactDefinition() throws Exception {
1558 ArtifactsBusinessLogic testSubject;
1559 Map<AuditingFieldsKeysEnum,Object> additionalParams = new HashMap<>();
1560 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1564 testSubject=createTestSubject();
1565 Deencapsulation.invoke(testSubject, "updateAuditParametersWithArtifactDefinition", new Object[]{additionalParams, artifactInfo});
1570 public void testSetNodeTemplateOperation() throws Exception {
1571 ArtifactsBusinessLogic testSubject;
1572 NodeTemplateOperation nodeTemplateOperation = null;
1575 testSubject = createTestSubject();
1576 Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", new Object[] { NodeTemplateOperation.class });