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=========================================================
19 * Modifications copyright (c) 2019 Nokia
20 * ================================================================================
23 package org.openecomp.sdc.be.components.impl;
25 import fj.data.Either;
26 import org.apache.commons.lang3.tuple.ImmutablePair;
27 import org.junit.Assert;
28 import org.junit.Before;
29 import org.junit.Test;
30 import org.mockito.InjectMocks;
31 import org.mockito.Mockito;
32 import org.mockito.MockitoAnnotations;
33 import org.openecomp.sdc.ElementOperationMock;
34 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
35 import org.openecomp.sdc.be.components.ArtifactsResolver;
36 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
37 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
38 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
39 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
40 import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils;
41 import org.openecomp.sdc.be.components.utils.ComponentBusinessLogicMock;
42 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
43 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
44 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
45 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
46 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
47 import org.openecomp.sdc.be.model.operations.StorageException;
48 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
49 import org.openecomp.sdc.be.components.csar.CsarInfo;
50 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
51 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
52 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
53 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
54 import org.openecomp.sdc.be.components.validation.UserValidations;
55 import org.openecomp.sdc.be.config.ConfigurationManager;
56 import org.openecomp.sdc.be.dao.api.ActionStatus;
57 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
58 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
59 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
60 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
61 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
62 import org.openecomp.sdc.be.impl.ComponentsUtils;
63 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
64 import org.openecomp.sdc.be.model.ArtifactDefinition;
65 import org.openecomp.sdc.be.model.Component;
66 import org.openecomp.sdc.be.model.DataTypeDefinition;
67 import org.openecomp.sdc.be.model.InputDefinition;
68 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
69 import org.openecomp.sdc.be.model.LifecycleStateEnum;
70 import org.openecomp.sdc.be.model.PropertyDefinition;
71 import org.openecomp.sdc.be.model.Resource;
72 import org.openecomp.sdc.be.model.User;
73 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
74 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
75 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation;
76 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation;
77 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
78 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
79 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
80 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
81 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
82 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
83 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
84 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
85 import org.openecomp.sdc.be.model.operations.impl.CsarOperation;
86 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
87 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
88 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
89 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
90 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
91 import org.openecomp.sdc.be.tosca.CsarUtils;
92 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
93 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
94 import org.openecomp.sdc.be.user.IUserBusinessLogic;
95 import org.openecomp.sdc.be.user.Role;
96 import org.openecomp.sdc.be.user.UserBusinessLogic;
97 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
98 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
99 import org.openecomp.sdc.common.api.ConfigurationSource;
100 import org.openecomp.sdc.common.api.Constants;
101 import org.openecomp.sdc.common.impl.ExternalConfiguration;
102 import org.openecomp.sdc.common.impl.FSConfigurationSource;
103 import org.openecomp.sdc.common.util.GeneralUtility;
104 import org.openecomp.sdc.common.util.ValidationUtils;
105 import org.openecomp.sdc.exception.ResponseFormat;
106 import org.slf4j.Logger;
107 import org.slf4j.LoggerFactory;
108 import org.springframework.web.context.WebApplicationContext;
110 import javax.servlet.ServletContext;
111 import java.io.IOException;
112 import java.lang.reflect.Method;
113 import java.util.ArrayList;
114 import java.util.EnumMap;
115 import java.util.HashMap;
116 import java.util.List;
117 import java.util.Map;
118 import java.util.stream.Collectors;
119 import java.util.stream.Stream;
121 import static org.junit.Assert.assertEquals;
122 import static org.junit.Assert.assertFalse;
123 import static org.junit.Assert.assertNotNull;
124 import static org.junit.Assert.assertTrue;
125 import static org.mockito.ArgumentMatchers.any;
126 import static org.mockito.ArgumentMatchers.anyString;
127 import static org.mockito.ArgumentMatchers.eq;
128 import static org.mockito.Mockito.when;
130 import static org.assertj.core.api.Java6Assertions.assertThat;
131 import static org.junit.Assert.assertNotEquals;
132 import static org.mockito.Mockito.times;
134 public class ResourceBusinessLogicTest extends ComponentBusinessLogicMock {
136 private static final Logger log = LoggerFactory.getLogger(ResourceBusinessLogicTest.class);
137 private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
138 private static final String RESOURCE_SUBCATEGORY = "Router";
140 private static final String UPDATED_SUBCATEGORY = "Gateway";
142 private String resourceId = "resourceId1";
143 private String operationId = "uniqueId1";
144 Resource resourceUpdate;
146 private static final String RESOURCE_NAME = "My-Resource_Name with space";
147 private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
148 private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF";
149 private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR";
150 private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF";
152 final ServletContext servletContext = Mockito.mock(ServletContext.class);
153 IElementOperation mockElementDao = new ElementOperationMock();
154 JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
155 UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
156 ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
157 NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class);
158 NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class);
159 TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
160 final LifecycleBusinessLogic lifecycleBl = Mockito.mock(LifecycleBusinessLogic.class);
161 final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class);
162 final PropertyOperation propertyOperation = Mockito.mock(PropertyOperation.class);
163 final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
164 WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
165 UserValidations userValidations = Mockito.mock(UserValidations.class);
166 WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
167 IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class);
168 ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class);
170 CsarUtils csarUtils = Mockito.mock(CsarUtils.class);
171 IUserBusinessLogic userBusinessLogic = Mockito.mock(IUserBusinessLogic.class);
172 IGroupOperation groupOperation = Mockito.mock(IGroupOperation.class);
173 IGroupInstanceOperation groupInstanceOperation = Mockito.mock(IGroupInstanceOperation.class);
174 IGroupTypeOperation groupTypeOperation = Mockito.mock(IGroupTypeOperation.class);
175 GroupBusinessLogic groupBusinessLogic = Mockito.mock(GroupBusinessLogic.class);
176 InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class);
177 ArtifactsOperations artifactToscaOperation = Mockito.mock(ArtifactsOperations.class);
178 ArtifactsResolver artifactsResolver = Mockito.mock(ArtifactsResolver.class);
179 InterfaceLifecycleOperation interfaceLifecycleTypeOperation = Mockito.mock(InterfaceLifecycleOperation.class);
180 ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
181 ResourceImportManager resourceImportManager = Mockito.mock(ResourceImportManager.class);
182 InputsBusinessLogic inputsBusinessLogic = Mockito.mock(InputsBusinessLogic.class);
183 CompositionBusinessLogic compositionBusinessLogic = Mockito.mock(CompositionBusinessLogic.class);
184 ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic = Mockito.mock(ResourceDataMergeBusinessLogic.class);
185 CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic = Mockito.mock(CsarArtifactsAndGroupsBusinessLogic.class);
186 MergeInstanceUtils mergeInstanceUtils = Mockito.mock(MergeInstanceUtils.class);
187 UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class);
189 ResponseFormatManager responseManager = null;
190 GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
192 Resource resourceResponse = null;
193 Resource genericVF = null;
194 Resource genericCR = null;
195 Resource genericVFC = null;
196 Resource genericPNF = null;
197 ComponentsUtils componentsUtils;
198 ArtifactsBusinessLogic artifactManager;
199 CsarOperation csarOperation = Mockito.mock(CsarOperation.class);
201 CsarBusinessLogic csarBusinessLogic;
202 Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
203 private GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
204 List<Resource> reslist;
205 ResourceBusinessLogic bl;
207 public ResourceBusinessLogicTest() {
211 public void setup() {
212 MockitoAnnotations.initMocks(this);
213 Mockito.reset(propertyOperation);
215 ExternalConfiguration.setAppName("catalog-be");
217 // init Configuration
218 String appConfigDir = "src/test/resources/config/catalog-be";
219 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
220 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
221 componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
223 ToscaExportHandler toscaExportHandler = Mockito.mock(ToscaExportHandler.class);
225 // User data and management
227 user.setUserId("jh0003");
228 user.setFirstName("Jimmi");
229 user.setLastName("Hendrix");
230 user.setRole(Role.ADMIN.name());
232 Either<User, ActionStatus> eitherGetUser = Either.left(user);
233 when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
234 when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).thenReturn(user);
235 when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
236 // Servlet Context attributes
237 when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
238 when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
239 when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
240 when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
242 Either<Integer, StorageOperationStatus> eitherCountRoot = Either.left(1);
243 Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true);
244 when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherFalse);
247 Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
248 when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
250 Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
251 when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
252 /*when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.VF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
253 when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.PNF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
254 when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);*/
255 Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
256 when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
258 Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false);
259 when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists);
260 when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
261 when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
264 resourceResponse = createResourceObject(true);
265 Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
266 Either<Integer, StorageOperationStatus> eitherValidate = Either.left(null);
267 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
268 Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
269 when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
270 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
273 artifactManager = new ArtifactsBusinessLogic(artifactCassandraDao, toscaExportHandler, csarUtils, lifecycleBl, userBusinessLogic,
274 artifactsResolver, mockElementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
275 interfaceLifecycleTypeOperation, artifactToscaOperation);
277 bl = new ResourceBusinessLogic(mockElementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic,
278 interfaceOperation, interfaceLifecycleTypeOperation, artifactManager, componentInstanceBusinessLogic,
279 resourceImportManager, inputsBusinessLogic, compositionBusinessLogic, resourceDataMergeBusinessLogic,
280 csarArtifactsAndGroupsBusinessLogic, mergeInstanceUtils, uiComponentDataConverter, csarBusinessLogic,
281 artifactToscaOperation);
283 artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
284 bl.setUserAdmin(mockUserAdmin);
285 bl.setCapabilityTypeOperation(capabilityTypeOperation);
286 bl.setComponentsUtils(componentsUtils);
287 bl.setLifecycleManager(lifecycleBl);
288 bl.setGraphLockOperation(graphLockOperation);
289 bl.setPropertyOperation(propertyOperation);
290 bl.setJanusGraphDao(mockJanusGraphDao);
291 bl.setApplicationDataTypeCache(applicationDataTypeCache);
292 bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic);
293 toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation);
294 toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation);
295 bl.setToscaOperationFacade(toscaOperationFacade);
296 bl.setUserValidations(userValidations);
297 bl.setInterfaceTypeOperation(interfaceTypeOperation);
299 csarBusinessLogic.setCsarOperation(csarOperation);
300 Resource resourceCsar = createResourceObjectCsar(true);
301 setCanWorkOnResource(resourceCsar);
302 Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar);
303 when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes);
304 responseManager = ResponseFormatManager.getInstance();
306 reslist = new ArrayList<Resource>();
307 reslist.add(resourceResponse);
308 reslist.add(genericVF);
309 reslist.add(genericCR);
310 reslist.add(genericVFC);
311 reslist.add(genericPNF);
312 Either<List<Resource>, StorageOperationStatus> returneval= Either.left(reslist);
313 when(toscaOperationFacade.getAllCertifiedResources(true, true)).thenReturn(returneval);
314 when(toscaOperationFacade.validateComponentNameUniqueness("Resource", ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(Either.left(true));
315 Either<List<Resource>, StorageOperationStatus> returnevalexception= Either.right(StorageOperationStatus.BAD_REQUEST);
316 when(toscaOperationFacade.getAllCertifiedResources(false, false)).thenReturn(returnevalexception);
320 private Resource createResourceObject(boolean afterCreate) {
321 Resource resource = new Resource();
322 resource.setName(RESOURCE_NAME);
323 resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
324 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
325 resource.setDescription("My short description");
326 List<String> tgs = new ArrayList<>();
328 tgs.add(resource.getName());
329 resource.setTags(tgs);
330 List<String> template = new ArrayList<>();
331 template.add("Root");
332 resource.setDerivedFrom(template);
333 resource.setVendorName("Motorola");
334 resource.setVendorRelease("1.0.0");
335 resource.setContactId("ya5467");
336 resource.setIcon("MyIcon");
339 resource.setName(resource.getName());
340 resource.setVersion("0.1");
341 resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
342 resource.setCreatorUserId(user.getUserId());
343 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
344 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
349 private Resource createResourceObjectCsar(boolean afterCreate) {
350 Resource resource = new Resource();
351 resource.setName(RESOURCE_NAME);
352 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
353 resource.setDescription("My short description");
354 List<String> tgs = new ArrayList<>();
356 tgs.add(resource.getName());
357 resource.setTags(tgs);
358 List<String> template = new ArrayList<>();
359 template.add("Root");
360 resource.setDerivedFrom(template);
361 resource.setVendorName("Motorola");
362 resource.setVendorRelease("1.0.0");
363 resource.setResourceVendorModelNumber("");
364 resource.setContactId("ya5467");
365 resource.setIcon("MyIcon");
366 resource.setCsarUUID("valid_vf.csar");
367 resource.setCsarVersion("1");
370 resource.setName(resource.getName());
371 resource.setVersion("0.1");
373 resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
374 resource.setCreatorUserId(user.getUserId());
375 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
376 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
381 private Resource setCanWorkOnResource(Resource resource) {
382 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
383 resource.setLastUpdaterUserId(user.getUserId());
388 public void testHappyScenario() {
389 validateUserRoles(Role.ADMIN, Role.DESIGNER);
390 Resource resource = createResourceObject(false);
391 Resource createdResource = null;
393 createdResource= bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
394 assertThat(createResourceObject(true)).isEqualTo(createdResource);
395 } catch(ByResponseFormatComponentException e){
396 assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
401 public void testUpdateHappyScenario() {
402 Resource resource = createResourceObjectCsar(true);
403 setCanWorkOnResource(resource);
404 validateUserRoles(Role.ADMIN, Role.DESIGNER);
405 Either<Resource, StorageOperationStatus> resourceLinkedToCsarRes = Either.left(resource);
406 when(toscaOperationFacade.getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, resource.getCsarUUID(), resource.getSystemName())).thenReturn(resourceLinkedToCsarRes);
407 Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
408 when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
409 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
410 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
411 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
412 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
413 Resource createdResource = null;
415 createdResource= bl.validateAndUpdateResourceFromCsar(resource, user, null, null, resource.getUniqueId());
416 assertThat(resource.getUniqueId()).isEqualTo(createdResource.getUniqueId());
417 } catch(ByResponseFormatComponentException e){
418 assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
424 public void testFailedResourceValidations() {
425 testResourceNameExist();
426 testResourceNameEmpty();
427 // testResourceNameExceedsLimit();
428 testResourceNameWrongFormat();
429 testResourceDescExceedsLimitCreate();
430 testResourceDescNotEnglish();
431 testResourceDescriptionEmpty();
432 testResourceDescriptionMissing();
433 testResourceIconMissing();
434 testResourceIconInvalid();
435 testResourceIconExceedsLimit();
436 testResourceTagNotExist();
437 testResourceTagEmpty();
438 testTagsExceedsLimitCreate();
439 testTagsNoServiceName();
442 testContactIdTooLong();
443 testContactIdWrongFormatCreate();
444 testResourceContactIdEmpty();
445 testResourceContactIdMissing();
446 testVendorNameExceedsLimit();
447 testVendorNameWrongFormatCreate();
448 testVendorReleaseWrongFormat();
449 testVendorReleaseExceedsLimitCreate();
450 testResourceVendorModelNumberExceedsLimit();
451 testResourceVendorNameMissing();
452 testResourceVendorReleaseMissing();
453 testResourceCategoryExist();
454 testResourceBadCategoryCreate();
455 testHappyScenarioCostLicenseType();
456 testCostWrongFormatCreate();
457 testLicenseTypeWrongFormatCreate();
458 testResourceTemplateNotExist();
459 testResourceTemplateEmpty();
460 testResourceTemplateInvalid();
463 private void testResourceNameExist() {
464 String resourceName = "alreadyExists";
465 Resource resourceExist = createResourceObject(false);
466 resourceExist.setName(resourceName);
467 resourceExist.getTags().add(resourceName);
468 validateUserRoles(Role.ADMIN, Role.DESIGNER);
470 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
471 } catch (ByResponseFormatComponentException e) {
472 assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resourceName);
476 private void testResourceNameEmpty() {
477 Resource resourceExist = createResourceObject(false);
478 resourceExist.setName(null);
481 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
482 } catch (ByActionStatusComponentException e) {
483 assertComponentException(e, ActionStatus.MISSING_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
487 private void testResourceNameExceedsLimit() {
488 Resource resourceExccedsNameLimit = createResourceObject(false);
489 // 51 chars, the limit is 50
490 String tooLongResourceName = "zCRCAWjqte0DtgcAAMmcJcXeNubeX1p1vOZNTShAHOYNAHvV3iK";
491 resourceExccedsNameLimit.setName(tooLongResourceName);
494 bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
495 } catch (ByActionStatusComponentException e) {
496 assertComponentException(e, ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
500 private void testResourceNameWrongFormat() {
501 Resource resource = createResourceObject(false);
503 String nameWrongFormat = "ljg?fd";
504 resource.setName(nameWrongFormat);
507 bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
508 } catch (ByActionStatusComponentException e) {
509 assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
513 // Resource name - end
514 // Resource description - start
515 private void testResourceDescExceedsLimitCreate() {
516 Resource resourceExccedsDescLimit = createResourceObject(false);
517 // 1025 chars, the limit is 1024
518 String tooLongResourceDesc = "1GUODojQ0sGzKR4NP7e5j82ADQ3KHTVOaezL95qcbuaqDtjZhAQGQ3iFwKAy580K4WiiXs3u3zq7RzXcSASl5fm0RsWtCMOIDP"
519 + "AOf9Tf2xtXxPCuCIMCR5wOGnNTaFxgnJEHAGxilBhZDgeMNHmCN1rMK5B5IRJOnZxcpcL1NeG3APTCIMP1lNAxngYulDm9heFSBc8TfXAADq7703AvkJT0QPpGq2z2P"
520 + "tlikcAnIjmWgfC5Tm7UH462BAlTyHg4ExnPPL4AO8c92VrD7kZSgSqiy73cN3gLT8uigkKrUgXQFGVUFrXVyyQXYtVM6bLBeuCGQf4C2j8lkNg6M0J3PC0PzMRoinOxk"
521 + "Ae2teeCtVcIj4A1KQo3210j8q2v7qQU69Mabsa6DT9FgE4rcrbiFWrg0Zto4SXWD3o1eJA9o29lTg6kxtklH3TuZTmpi5KVp1NFhS1RpnqF83tzv4mZLKsx7Zh1fEgYvRFwx1"
522 + "ar3RolyDfNoZiGBGTMsZzz7RPFBf2hTnLmNqVGQnHKhhGj0Y5s8t2cbqbO2nmHiJb9uaUVrCGypgbAcJL3KPOBfAVW8PcpmNj4yVjI3L4x5zHjmGZbp9vKshEQODcrmcgsYAoKqe"
523 + "uu5u7jk8XVxEfQ0m5qL8UOErXPlJovSmKUmP5B5T0w299zIWDYCzSoNasHpHjOMDLAiDDeHbozUOn9t3Qou00e9POq4RMM0VnIx1H38nJoJZz2XH8CI5YMQe7oTagaxgQTF2aa0qaq2"
524 + "V6nJsfRGRklGjNhFFYP2cS4Xv2IJO9DSX6LTXOmENrGVJJvMOZcvnBaZPfoAHN0LU4i1SoepLzulIxnZBfkUWFJgZ5wQ0Bco2GC1HMqzW21rwy4XHRxXpXbmW8LVyoA1KbnmVmROycU4"
525 + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
527 resourceExccedsDescLimit.setDescription(tooLongResourceDesc);
529 bl.createResource(resourceExccedsDescLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
530 } catch (ByActionStatusComponentException e) {
531 assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH);
535 private void testResourceDescNotEnglish() {
536 Resource notEnglish = createResourceObject(false);
538 String notEnglishDesc = "\uC2B5";
539 notEnglish.setDescription(notEnglishDesc);
542 bl.createResource(notEnglish, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
543 } catch (ByActionStatusComponentException e) {
544 assertComponentException(e, ActionStatus.COMPONENT_INVALID_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
548 private void testResourceDescriptionEmpty() {
549 Resource resourceExist = createResourceObject(false);
550 resourceExist.setDescription("");
553 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
554 } catch (ByActionStatusComponentException e) {
555 assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
559 private void testResourceDescriptionMissing() {
560 Resource resourceExist = createResourceObject(false);
561 resourceExist.setDescription(null);
564 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
565 } catch (ByActionStatusComponentException e) {
566 assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
569 // Resource description - end
570 // Resource icon start
572 private void testResourceIconMissing() {
573 Resource resourceExist = createResourceObject(false);
574 resourceExist.setIcon(null);
577 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
578 } catch (ByActionStatusComponentException e) {
579 assertComponentException(e, ActionStatus.COMPONENT_MISSING_ICON, ComponentTypeEnum.RESOURCE.getValue());
583 private void testResourceIconInvalid() {
584 Resource resourceExist = createResourceObject(false);
585 resourceExist.setIcon("kjk3453^&");
588 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
589 } catch (ByActionStatusComponentException e) {
590 assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue());
594 private void testResourceIconExceedsLimit() {
595 Resource resourceExist = createResourceObject(false);
596 resourceExist.setIcon("dsjfhskdfhskjdhfskjdhkjdhfkshdfksjsdkfhsdfsdfsdfsfsdfsf");
598 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
599 } catch (ByActionStatusComponentException e) {
600 assertComponentException(e, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.ICON_MAX_LENGTH);
605 // Resource tags - start
606 private void testResourceTagNotExist() {
607 Resource resourceExist = createResourceObject(false);
608 resourceExist.setTags(null);
610 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
611 } catch (ByActionStatusComponentException e) {
612 assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS);
616 private void testResourceTagEmpty() {
617 Resource resourceExist = createResourceObject(false);
618 resourceExist.setTags(new ArrayList<>());
620 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
621 } catch (ByActionStatusComponentException e) {
622 assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS);
626 private void testTagsExceedsLimitCreate() {
627 Resource resourceExccedsNameLimit = createResourceObject(false);
628 String tag1 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjQ";
629 String tag2 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjW";
630 String tag3 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjE";
631 String tag4 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjb";
632 String tag5 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjr";
633 String tag6 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
634 String tag7 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
635 String tag8 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjd";
636 String tag9 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
637 String tag10 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
638 String tag11 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjh";
639 String tag12 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjj";
640 String tag13 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjk";
641 String tag14 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjs";
642 String tag15 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjz";
643 String tag16 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjx";
644 String tag17 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj2";
645 String tag18 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj3";
646 String tag19 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj4";
647 String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
648 String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
650 List<String> tagsList = new ArrayList<>();
672 tagsList.add(resourceExccedsNameLimit.getName());
674 resourceExccedsNameLimit.setTags(tagsList);
676 bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
677 } catch (ByActionStatusComponentException e) {
678 assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, "" + ValidationUtils.TAG_LIST_MAX_LENGTH);
682 private void testTagsSingleExceedsLimit() {
683 Resource resourceExccedsNameLimit = createResourceObject(false);
684 String tag1 = "afzs2qLBb5X6tZhiunkcEwiFX1qRQY8YZl3y3Du5M5xeQY5Nq9afcFHDZ9HaURw43gH27nAUWM36bMbMylwTFSzzNV8NO4v4ripe6Q15Vc2nPOFI";
685 String tag2 = resourceExccedsNameLimit.getName();
686 List<String> tagsList = new ArrayList<>();
690 resourceExccedsNameLimit.setTags(tagsList);
692 bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
693 } catch (ByActionStatusComponentException e) {
694 assertComponentException(e, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT, "" + ValidationUtils.TAG_MAX_LENGTH);
698 private void testTagsNoServiceName() {
699 Resource serviceExccedsNameLimit = createResourceObject(false);
700 String tag1 = "afzs2qLBb";
701 List<String> tagsList = new ArrayList<>();
703 serviceExccedsNameLimit.setTags(tagsList);
705 bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
706 } catch (ByActionStatusComponentException e) {
707 assertComponentException(e, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME);
711 private void testInvalidTag() {
712 Resource serviceExccedsNameLimit = createResourceObject(false);
713 String tag1 = "afzs2qLBb%#%";
714 List<String> tagsList = new ArrayList<>();
716 serviceExccedsNameLimit.setTags(tagsList);
718 bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
719 } catch (ByActionStatusComponentException e) {
720 assertComponentException(e, ActionStatus.INVALID_FIELD_FORMAT, new String[]{"Resource", "tag"});
724 // Resource tags - stop
725 // Resource contact start
727 private void testContactIdTooLong() {
728 Resource resourceContactId = createResourceObject(false);
729 // 59 chars instead of 50
730 String contactIdTooLong = "thisNameIsVeryLongAndExeccedsTheNormalLengthForContactId";
731 resourceContactId.setContactId(contactIdTooLong);
734 bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
735 } catch (ByActionStatusComponentException e) {
736 assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
740 private void testContactIdWrongFormatCreate() {
741 Resource resourceContactId = createResourceObject(false);
742 // 3 letters and 3 digits and special characters
743 String contactIdFormatWrong = "yrt134!!!";
744 resourceContactId.setContactId(contactIdFormatWrong);
746 bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
747 } catch (ByActionStatusComponentException e) {
748 assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
752 private void testResourceContactIdEmpty() {
753 Resource resourceExist = createResourceObject(false);
754 resourceExist.setContactId("");
756 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
757 } catch (ByActionStatusComponentException e) {
758 assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
762 private void testResourceContactIdMissing() {
763 Resource resourceExist = createResourceObject(false);
764 resourceExist.setContactId(null);
766 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
767 } catch (ByActionStatusComponentException e) {
768 assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
772 private void testVendorNameExceedsLimit() {
773 Resource resourceExccedsVendorNameLimit = createResourceObject(false);
774 String tooLongVendorName = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
775 resourceExccedsVendorNameLimit.setVendorName(tooLongVendorName);
777 bl.createResource(resourceExccedsVendorNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
778 } catch (ByActionStatusComponentException e) {
779 assertComponentException(e, ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
783 private void testResourceVendorModelNumberExceedsLimit() {
784 Resource resourceExccedsVendorModelNumberLimit = createResourceObject(false);
785 String tooLongVendorModelNumber = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
786 resourceExccedsVendorModelNumberLimit.setResourceVendorModelNumber(tooLongVendorModelNumber);
788 bl.createResource(resourceExccedsVendorModelNumberLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
789 } catch (ByActionStatusComponentException e) {
790 assertComponentException(e, ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT, "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
794 private void testVendorNameWrongFormatCreate() {
795 Resource resource = createResourceObject(false);
797 String nameWrongFormat = "ljg*fd";
798 resource.setVendorName(nameWrongFormat);
800 bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
801 } catch (ByActionStatusComponentException e) {
802 assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME, nameWrongFormat);
806 private void testVendorReleaseWrongFormat() {
807 Resource resource = createResourceObject(false);
809 String vendorReleaseWrongFormat = "1>2";
810 resource.setVendorRelease(vendorReleaseWrongFormat);
812 bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
813 } catch (ByActionStatusComponentException e) {
814 assertComponentException(e, ActionStatus.INVALID_VENDOR_RELEASE, vendorReleaseWrongFormat);
818 private void testVendorReleaseExceedsLimitCreate() {
819 Resource resourceExccedsNameLimit = createResourceObject(false);
820 String tooLongVendorRelease = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
821 resourceExccedsNameLimit.setVendorRelease(tooLongVendorRelease);
823 bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
824 } catch (ByActionStatusComponentException e) {
825 assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
829 private void testResourceVendorNameMissing() {
830 Resource resourceExist = createResourceObject(false);
831 resourceExist.setVendorName(null);
833 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
834 } catch (ByActionStatusComponentException e) {
835 assertComponentException(e, ActionStatus.MISSING_VENDOR_NAME);
839 private void testResourceVendorReleaseMissing() {
840 Resource resourceExist = createResourceObject(false);
841 resourceExist.setVendorRelease(null);
843 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
844 } catch (ByActionStatusComponentException e) {
845 assertComponentException(e, ActionStatus.MISSING_VENDOR_RELEASE);
849 // Resource vendor name/release stop
851 private void testResourceCategoryExist() {
852 Resource resourceExist = createResourceObject(false);
853 resourceExist.setCategories(null);
855 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
856 } catch (ByActionStatusComponentException e) {
857 assertComponentException(e, ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
861 private void testResourceBadCategoryCreate() {
863 Resource resourceExist = createResourceObject(false);
864 resourceExist.setCategories(null);
865 resourceExist.addCategory("koko", "koko");
867 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
868 } catch (ByActionStatusComponentException e) {
869 assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
875 private void testHappyScenarioCostLicenseType() {
876 Resource createResourceObject = createResourceObject(false);
877 Resource createResourceObjectAfterCreate = createResourceObject(true);
878 // Adding cost and licenseType to basic mock
879 Either<Resource, StorageOperationStatus> eitherCreate = Either.left(createResourceObjectAfterCreate);
880 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
882 String cost = "123.456";
883 String licenseType = "User";
884 createResourceObject.setCost(cost);
885 createResourceObject.setLicenseType(licenseType);
886 Resource createdResource;
888 createdResource = bl.createResource(createResourceObject, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
889 createResourceObjectAfterCreate.setCost(cost);
890 createResourceObjectAfterCreate.setLicenseType(licenseType);
891 assertThat(createResourceObjectAfterCreate).isEqualTo(createdResource);
892 }catch(ByResponseFormatComponentException e){
893 assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
897 private void testCostWrongFormatCreate() {
898 Resource resourceCost = createResourceObject(false);
899 // Comma instead of fullstop
900 String cost = "12356,464";
901 resourceCost.setCost(cost);
903 bl.createResource(resourceCost, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
904 } catch (ByActionStatusComponentException e) {
905 assertComponentException(e, ActionStatus.INVALID_CONTENT);
910 // License type start
911 private void testLicenseTypeWrongFormatCreate() {
912 Resource resourceLicenseType = createResourceObject(false);
914 String licenseType = "cpu";
915 resourceLicenseType.setLicenseType(licenseType);
917 bl.createResource(resourceLicenseType, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
918 } catch (ByActionStatusComponentException e) {
919 assertComponentException(e, ActionStatus.INVALID_CONTENT);
924 // Derived from start
925 private void testResourceTemplateNotExist() {
926 Resource resourceExist = createResourceObject(false);
927 List<String> list = null;
928 resourceExist.setDerivedFrom(list);
930 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
931 } catch (ByActionStatusComponentException e) {
932 assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
936 private void testResourceTemplateEmpty() {
937 Resource resourceExist = createResourceObject(false);
938 resourceExist.setDerivedFrom(new ArrayList<>());
940 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
941 } catch (ByActionStatusComponentException e) {
942 assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
946 private void testResourceTemplateInvalid() {
947 Resource resourceExist = createResourceObject(false);
948 ArrayList<String> derivedFrom = new ArrayList<>();
949 derivedFrom.add("kuku");
950 resourceExist.setDerivedFrom(derivedFrom);
952 bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
953 } catch (ByResponseFormatComponentException e) {
954 assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
955 } catch (ByActionStatusComponentException e) {
956 assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
960 private void assertComponentException(ByResponseFormatComponentException e, ActionStatus expectedStatus, String... variables) {
961 ResponseFormat actualResponse = e.getResponseFormat();
962 assertResponse(actualResponse, expectedStatus, variables);
965 private void assertComponentException(ByActionStatusComponentException e, ActionStatus expectedStatus, String... variables) {
966 ResponseFormat actualResponse = componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
967 assertResponse(actualResponse, expectedStatus, variables);
970 private void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
971 ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
972 assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
973 assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
976 private void assertResponse(Either<Resource, ResponseFormat> createResponse, ActionStatus expectedStatus, String... variables) {
977 assertResponse(createResponse.right().value(), expectedStatus, variables);
980 // UPDATE tests - start
983 public void testResourceNameWrongFormat_UPDATE() {
984 Resource resource = createResourceObject(true);
985 Resource updatedResource = createResourceObject(true);
987 // this is in order to prevent failing with 403 earlier
988 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
989 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
991 String nameWrongFormat = "ljg*fd";
992 updatedResource.setName(nameWrongFormat);
994 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
995 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
997 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
998 } catch (ByActionStatusComponentException e) {
999 assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
1004 public void testResourceNameAfterCertify_UPDATE() {
1005 Resource resource = createResourceObject(true);
1006 Resource updatedResource = createResourceObject(true);
1008 // this is in order to prevent failing with 403 earlier
1009 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1010 // when(resourceOperation.getResource_tx(resource.getUniqueId(),false)).thenReturn(eitherUpdate);
1011 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1013 String name = "ljg";
1014 updatedResource.setName(name);
1015 resource.setVersion("1.0");
1017 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1018 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1020 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1021 } catch (ByActionStatusComponentException e) {
1022 assertComponentException(e, ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED);
1027 public void testResourceNameAlreadyExist_UPDATE() {
1028 Resource resource = createResourceObject(true);
1029 Resource updatedResource = createResourceObject(true);
1031 // this is in order to prevent failing with 403 earlier
1032 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1033 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1035 String resourceName = "alreadyExists";
1036 updatedResource.setName(resourceName);
1037 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
1038 when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1040 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1041 } catch (ByActionStatusComponentException e) {
1042 assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resourceName);
1049 public void testResourceDescExceedsLimit_UPDATE() {
1050 Resource resource = createResourceObject(true);
1051 Resource updatedResource = createResourceObject(true);
1053 // this is in order to prevent failing with 403 earlier
1054 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1055 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1057 // 1025 chars, the limit is 1024
1058 String tooLongResourceDesc = "1GUODojQ0sGzKR4NP7e5j82ADQ3KHTVOaezL95qcbuaqDtjZhAQGQ3iFwKAy580K4WiiXs3u3zq7RzXcSASl5fm0RsWtCMOIDP"
1059 + "AOf9Tf2xtXxPCuCIMCR5wOGnNTaFxgnJEHAGxilBhZDgeMNHmCN1rMK5B5IRJOnZxcpcL1NeG3APTCIMP1lNAxngYulDm9heFSBc8TfXAADq7703AvkJT0QPpGq2z2P"
1060 + "tlikcAnIjmWgfC5Tm7UH462BAlTyHg4ExnPPL4AO8c92VrD7kZSgSqiy73cN3gLT8uigkKrUgXQFGVUFrXVyyQXYtVM6bLBeuCGQf4C2j8lkNg6M0J3PC0PzMRoinOxk"
1061 + "Ae2teeCtVcIj4A1KQo3210j8q2v7qQU69Mabsa6DT9FgE4rcrbiFWrg0Zto4SXWD3o1eJA9o29lTg6kxtklH3TuZTmpi5KVp1NFhS1RpnqF83tzv4mZLKsx7Zh1fEgYvRFwx1"
1062 + "ar3RolyDfNoZiGBGTMsZzz7RPFBf2hTnLmNqVGQnHKhhGj0Y5s8t2cbqbO2nmHiJb9uaUVrCGypgbAcJL3KPOBfAVW8PcpmNj4yVjI3L4x5zHjmGZbp9vKshEQODcrmcgsYAoKqe"
1063 + "uu5u7jk8XVxEfQ0m5qL8UOErXPlJovSmKUmP5B5T0w299zIWDYCzSoNasHpHjOMDLAiDDeHbozUOn9t3Qou00e9POq4RMM0VnIx1H38nJoJZz2XH8CI5YMQe7oTagaxgQTF2aa0qaq2"
1064 + "V6nJsfRGRklGjNhFFYP2cS4Xv2IJO9DSX6LTXOmENrGVJJvMOZcvnBaZPfoAHN0LU4i1SoepLzulIxnZBfkUWFJgZ5wQ0Bco2GC1HMqzW21rwy4XHRxXpXbmW8LVyoA1KbnmVmROycU4"
1065 + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
1066 updatedResource.setDescription(tooLongResourceDesc);
1067 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1068 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1070 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1071 } catch (ByActionStatusComponentException e) {
1072 assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH);
1077 public void testIconWrongFormat_UPDATE() {
1078 Resource resource = createResourceObject(true);
1079 Resource updatedResource = createResourceObject(true);
1081 // this is in order to prevent failing with 403 earlier
1082 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1083 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1086 String icon = "icon.jpg";
1087 updatedResource.setIcon(icon);
1088 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1089 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1091 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1092 } catch (ByActionStatusComponentException e) {
1093 assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue());
1098 public void testIconAfterCertify_UPDATE() {
1099 Resource resource = createResourceObject(true);
1100 Resource updatedResource = createResourceObject(true);
1102 // this is in order to prevent failing with 403 earlier
1103 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1104 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1107 String icon = "icon";
1108 updatedResource.setIcon(icon);
1110 resource.setVersion("1.0");
1112 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1113 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1115 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1116 } catch (ByActionStatusComponentException e) {
1117 assertComponentException(e, ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED);
1122 public void testTagsExceedsLimit_UPDATE() {
1123 Resource resource = createResourceObject(true);
1124 Resource updatedResource = createResourceObject(true);
1126 // this is in order to prevent failing with 403 earlier
1127 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1128 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1130 String tag1 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjQ";
1131 String tag2 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjW";
1132 String tag3 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjE";
1133 String tag4 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjb";
1134 String tag5 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjr";
1135 String tag6 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
1136 String tag7 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
1137 String tag8 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjd";
1138 String tag9 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
1139 String tag10 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
1140 String tag11 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjh";
1141 String tag12 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjj";
1142 String tag13 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjk";
1143 String tag14 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjs";
1144 String tag15 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjz";
1145 String tag16 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjx";
1146 String tag17 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj2";
1147 String tag18 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj3";
1148 String tag19 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj4";
1149 String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
1150 String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
1152 List<String> tagsList = new ArrayList<>();
1162 tagsList.add(tag10);
1163 tagsList.add(tag11);
1164 tagsList.add(tag12);
1165 tagsList.add(tag13);
1166 tagsList.add(tag14);
1167 tagsList.add(tag15);
1168 tagsList.add(tag16);
1169 tagsList.add(tag17);
1170 tagsList.add(tag18);
1171 tagsList.add(tag19);
1172 tagsList.add(tag20);
1173 tagsList.add(tag21);
1174 tagsList.add(resource.getName());
1176 updatedResource.setTags(tagsList);
1177 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1178 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1180 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1181 } catch (ByActionStatusComponentException e) {
1182 assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, "" + ValidationUtils.TAG_LIST_MAX_LENGTH);
1187 public void testVendorNameWrongFormat_UPDATE() {
1188 Resource resource = createResourceObject(true);
1189 Resource updatedResource = createResourceObject(true);
1191 // this is in order to prevent failing with 403 earlier
1192 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1193 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1196 String nameWrongFormat = "ljg*fd";
1197 updatedResource.setVendorName(nameWrongFormat);
1198 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1199 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1201 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1202 } catch (ByActionStatusComponentException e) {
1203 assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME, nameWrongFormat);
1208 public void testVendorNameWrongFormat() {
1209 Resource resource = createResourceObject(true);
1210 Resource updatedResource = createResourceObject(true);
1212 // this is in order to prevent failing with 403 earlier
1213 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1214 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1217 String nameWrongFormat = "ljg*fd";
1218 updatedResource.setVendorName(nameWrongFormat);
1219 resource.setVersion("1.0");
1221 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1222 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1224 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1225 } catch (ByActionStatusComponentException e) {
1226 assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME, nameWrongFormat);
1231 public void testVendorReleaseExceedsLimit_UPDATE() {
1232 Resource resource = createResourceObject(true);
1233 Resource updatedResource = createResourceObject(true);
1235 // this is in order to prevent failing with 403 earlier
1236 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1237 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1238 // 129 chars, the limit is 128
1239 String tooLongVendorRelease = "h1KSyJh9EspI8SPwAGu4VETfqWejeanuB1PCJBxJmJncYnrW0lnsEFFVRIukRJkwlOVnZCy8p38tjhANeZq3BGMHIawWR6ICl8Wi9mikRYALWgvJug00JrlQ0iPVKPLxy";
1240 updatedResource.setVendorRelease(tooLongVendorRelease);
1241 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1242 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1244 bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1245 } catch (ByActionStatusComponentException e) {
1246 assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
1251 public void testResourceBadCategory_UPDATE() {
1252 Resource resource = createResourceObject(true);
1253 Resource updatedResource = createResourceObject(true);
1255 // this is in order to prevent failing with 403 earlier
1256 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1257 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1259 String resourceId = resource.getUniqueId();
1260 String badCategory = "ddfds";
1261 updatedResource.setCategories(null);
1262 updatedResource.addCategory(badCategory, "fikt");
1263 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1264 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1266 bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1267 } catch (ByActionStatusComponentException e) {
1268 assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
1273 public void testResourceCategoryAfterCertify_UPDATE() {
1274 Resource resource = createResourceObject(true);
1275 Resource updatedResource = createResourceObject(true);
1277 // this is in order to prevent failing with 403 earlier
1278 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1279 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1281 String resourceId = resource.getUniqueId();
1282 updatedResource.setCategories(null);
1283 updatedResource.addCategory(RESOURCE_CATEGORY1, UPDATED_SUBCATEGORY);
1284 resource.setVersion("1.0");
1286 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1287 when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1289 bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1290 } catch (ByActionStatusComponentException e) {
1291 assertComponentException(e, ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED);
1295 // Derived from start
1297 public void testResourceTemplateNotExist_UPDATE() {
1298 Resource resource = createResourceObject(true);
1299 Resource updatedResource = createResourceObject(true);
1301 // this is in order to prevent failing with 403 earlier
1302 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1303 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1304 String resourceId = resource.getUniqueId();
1306 List<String> list = null;
1307 updatedResource.setDerivedFrom(list);
1308 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1309 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1311 bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1312 } catch (ByActionStatusComponentException e) {
1313 assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
1318 public void testResourceTemplateEmpty_UPDATE() {
1319 Resource resource = createResourceObject(true);
1320 Resource updatedResource = createResourceObject(true);
1321 String resourceId = resource.getUniqueId();
1323 // this is in order to prevent failing with 403 earlier
1324 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1325 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1327 updatedResource.setDerivedFrom(new ArrayList<>());
1328 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1329 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1331 bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1332 } catch (ByActionStatusComponentException e) {
1333 assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
1338 public void testResourceTemplateInvalid_UPDATE() {
1339 Resource resource = createResourceObject(true);
1340 Resource updatedResource = createResourceObject(true);
1341 String resourceId = resource.getUniqueId();
1343 // this is in order to prevent failing with 403 earlier
1344 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1345 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1347 ArrayList<String> derivedFrom = new ArrayList<>();
1348 derivedFrom.add("kuku");
1349 updatedResource.setDerivedFrom(derivedFrom);
1350 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1351 when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1353 bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1354 } catch (ByActionStatusComponentException e) {
1355 assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
1360 public void testResourceTemplateCertify_UPDATE_HAPPY() {
1361 Resource resource = createResourceObject(true);
1362 Resource updatedResource = createResourceObject(true);
1363 String resourceId = resource.getUniqueId();
1365 // this is in order to prevent failing with 403 earlier
1366 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1367 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1369 Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(true);
1370 when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString())).thenReturn(isToscaNameExtending);
1372 Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = Either.left(new HashMap<>());
1373 when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), Mockito.anyString())).thenReturn(findPropertiesOfNode);
1375 resource.setVersion("1.0");
1377 ArrayList<String> derivedFrom = new ArrayList<>();
1378 derivedFrom.add("tosca.nodes.Root");
1379 updatedResource.setDerivedFrom(derivedFrom);
1380 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
1381 when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1382 Resource createdResource = bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1383 assertThat(createdResource).isNotNull();
1387 public void testResourceTemplateCertify_UPDATE_SAD() {
1388 Resource resource = createResourceObject(true);
1389 Resource updatedResource = createResourceObject(true);
1390 String resourceId = resource.getUniqueId();
1392 // this is in order to prevent failing with 403 earlier
1393 Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1394 when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1396 Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(false);
1397 when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString()))
1398 .thenReturn(isToscaNameExtending);
1400 resource.setVersion("1.0");
1402 ArrayList<String> derivedFrom = new ArrayList<>();
1403 derivedFrom.add("tosca.nodes.Root");
1404 updatedResource.setDerivedFrom(derivedFrom);
1405 Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1406 when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1407 Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = Either.left(new HashMap<>());
1408 when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), Mockito.anyString())).thenReturn(findPropertiesOfNode);
1411 bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1412 } catch (ByActionStatusComponentException e) {
1413 assertComponentException(e, ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND);
1416 // Derived from stop
1419 public void createOrUpdateResourceAlreadyCheckout() {
1420 Resource resourceExist = createResourceObject(false);
1421 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1422 Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1423 createdResource.setLastUpdaterUserId(user.getUserId());
1424 assertThat(createdResource).isNotNull();
1425 Either<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
1426 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(createdResource);
1427 when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())).thenReturn(getCompLatestResult);
1428 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(getLatestResult);
1430 Resource resourceToUpdtae = createResourceObject(false);
1432 ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1433 assertNotNull(createOrUpdateResource);
1435 Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1436 Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1441 public void createOrUpdateResourceCertified() {
1442 Resource resourceExist = createResourceObject(false);
1443 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1444 Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1446 assertThat(createdResource).isNotNull();
1447 createdResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1448 createdResource.setVersion("1.0");
1450 Either<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
1451 Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(createdResource);
1452 when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())).thenReturn(getCompLatestResult); when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(getLatestResult);
1454 when(lifecycleBl.changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean())).thenReturn(Either.left(createdResource));
1456 Resource resourceToUpdtae = createResourceObject(false);
1458 ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1459 assertNotNull(createOrUpdateResource);
1461 Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1462 Mockito.verify(lifecycleBl, Mockito.times(1)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1467 public void createOrUpdateResourceNotExist() {
1468 Resource resourceToUpdtae = createResourceObject(false);
1470 Either<Component, StorageOperationStatus> getLatestResult = Either.right(StorageOperationStatus.NOT_FOUND);
1471 when(toscaOperationFacade.getLatestByName(resourceToUpdtae.getName())).thenReturn(getLatestResult);
1473 Either<Component, StorageOperationStatus> getLatestToscaNameResult = Either.right(StorageOperationStatus.NOT_FOUND);
1474 when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdtae.getToscaResourceName())).thenReturn(getLatestToscaNameResult);
1476 ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1477 assertThat(createOrUpdateResource).isNotNull();
1479 Mockito.verify(toscaOperationFacade, times(1)).createToscaComponent(eq(resourceToUpdtae));
1480 Mockito.verify(toscaOperationFacade, Mockito.times(0)).overrideComponent(any(Resource.class), any(Resource.class));
1481 Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1486 public void updateNestedResource_typeIsNew() throws IOException {
1487 Resource resourceToUpdate = createResourceObject(false);
1488 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc";
1489 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
1490 CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(),
1491 RESOURCE_NAME, "template name", jsonContent, true);
1492 String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight();
1493 when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1494 when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1495 when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1497 ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo,
1499 assertThat(createOrUpdateResource).isNotNull();
1501 Mockito.verify(toscaOperationFacade, times(1)).createToscaComponent(eq(resourceToUpdate));
1502 Mockito.verify(toscaOperationFacade, times(0)).overrideComponent(any(Resource.class), any(Resource.class));
1503 Mockito.verify(lifecycleBl, times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1507 public void updateNestedResource_typeExists() throws IOException {
1508 Resource resourceToUpdate = createResourceObject(false);
1509 setCanWorkOnResource(resourceResponse);
1510 String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc";
1511 String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
1512 CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(),
1513 RESOURCE_NAME, "template name", jsonContent, true);
1514 String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight();
1515 when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1516 when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1517 when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)).thenReturn(Either.left(resourceResponse));
1518 when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(Either.left(resourceResponse));
1520 ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo,
1522 assertThat(createOrUpdateResource).isNotNull();
1523 Mockito.verify(toscaOperationFacade, times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1524 Mockito.verify(lifecycleBl, times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1528 public void testValidatePropertiesDefaultValues_SuccessfullWithoutProperties() {
1529 Resource basic = createResourceObject(true);
1531 Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1532 assertTrue(validatePropertiesDefaultValues.isLeft());
1536 public void testValidatePropertiesDefaultValues_SuccessfullWithProperties() {
1537 Resource basic = createResourceObject(true);
1538 PropertyDefinition property = new PropertyDefinition();
1539 property.setName("myProperty");
1540 property.setType(ToscaPropertyType.INTEGER.getType());
1541 property.setDefaultValue("1");
1542 List<PropertyDefinition> properties = new ArrayList<>();
1543 properties.add(property);
1544 basic.setProperties(properties);
1545 when(propertyOperation.isPropertyTypeValid(property)).thenReturn(true);
1546 when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(true);
1547 Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1548 assertTrue(validatePropertiesDefaultValues.isLeft());
1552 public void testValidatePropertiesDefaultValues_FailedWithProperties() {
1553 Resource basic = createResourceObject(true);
1554 PropertyDefinition property = new PropertyDefinition();
1555 property.setName("myProperty");
1556 property.setType(ToscaPropertyType.INTEGER.getType());
1557 property.setDefaultValue("1.5");
1558 List<PropertyDefinition> properties = new ArrayList<>();
1559 properties.add(property);
1560 basic.setProperties(properties);
1562 when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(false);
1563 Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1564 assertTrue(validatePropertiesDefaultValues.isRight());
1568 @SuppressWarnings("unchecked")
1570 public void testFindVfCsarArtifactsToHandle() {
1572 Class<ResourceBusinessLogic> targetClass = ResourceBusinessLogic.class;
1573 String methodName = "findVfCsarArtifactsToHandle";
1574 Resource resource = new Resource();
1575 String deploymentArtifactToUpdateFileName = "deploymentArtifactToUpdate.yaml";
1576 String deploymentArtifactToDeleteFileName = "deploymentArtifactToDelete.yaml";
1577 String deploymentArtifactToCreateFileName = "deploymentArtifactToCreate.yaml";
1579 String artifactInfoToUpdateFileName = "infoArtifactToUpdate.yaml";
1580 String artifactInfoToDeleteFileName = "infoArtifactToDelete.yaml";
1581 String artifactInfoToNotDeleteFileName = "infoArtifactNotToDelete.yaml";
1582 String artifactInfoToCreateFileName = "infoArtifactToCreate.yaml";
1584 byte[] oldPayloadData = "oldPayloadData".getBytes();
1585 byte[] newPayloadData = "newPayloadData".getBytes();
1586 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
1588 ArtifactDefinition deploymentArtifactToUpdate = new ArtifactDefinition();
1589 deploymentArtifactToUpdate.setMandatory(false);
1590 deploymentArtifactToUpdate.setArtifactName(deploymentArtifactToUpdateFileName);
1591 deploymentArtifactToUpdate.setArtifactType("SNMP_POLL");
1592 deploymentArtifactToUpdate.setPayload(oldPayloadData);
1593 deploymentArtifactToUpdate.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1595 ArtifactDefinition deploymentArtifactToDelete = new ArtifactDefinition();
1596 deploymentArtifactToDelete.setMandatory(false);
1597 deploymentArtifactToDelete.setArtifactName(deploymentArtifactToDeleteFileName);
1598 deploymentArtifactToDelete.setArtifactType("SNMP_TRAP");
1599 deploymentArtifactToDelete.setPayload(oldPayloadData);
1600 deploymentArtifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1602 ArtifactDefinition deploymentArtifactToIgnore = new ArtifactDefinition();
1604 deploymentArtifacts.put(ValidationUtils.normalizeArtifactLabel(deploymentArtifactToUpdate.getArtifactName()), deploymentArtifactToUpdate);
1605 deploymentArtifacts.put(ValidationUtils.normalizeArtifactLabel(deploymentArtifactToDelete.getArtifactName()), deploymentArtifactToDelete);
1606 deploymentArtifacts.put("ignore", deploymentArtifactToIgnore);
1608 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1610 ArtifactDefinition artifactToUpdate = new ArtifactDefinition();
1611 artifactToUpdate.setMandatory(false);
1612 artifactToUpdate.setArtifactName(artifactInfoToUpdateFileName);
1613 artifactToUpdate.setArtifactType("SNMP_POLL");
1614 artifactToUpdate.setPayload(oldPayloadData);
1615 artifactToUpdate.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1617 ArtifactDefinition artifactToDelete = new ArtifactDefinition();
1618 artifactToDelete.setMandatory(false);
1619 artifactToDelete.setArtifactName(artifactInfoToDeleteFileName);
1620 artifactToDelete.setArtifactType("SNMP_TRAP");
1621 artifactToDelete.setPayload(oldPayloadData);
1622 artifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1623 artifactToDelete.setIsFromCsar(true);
1625 ArtifactDefinition artifactToNotDelete = new ArtifactDefinition();
1626 artifactToNotDelete.setMandatory(false);
1627 artifactToNotDelete.setArtifactName(artifactInfoToNotDeleteFileName);
1628 artifactToNotDelete.setArtifactType("SNMP_TRAP");
1629 artifactToNotDelete.setPayload(oldPayloadData);
1630 artifactToNotDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1631 artifactToNotDelete.setIsFromCsar(false);
1633 ArtifactDefinition artifactToIgnore = new ArtifactDefinition();
1635 artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToUpdate.getArtifactName()), artifactToUpdate);
1636 artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToDelete.getArtifactName()), artifactToDelete);
1637 artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToNotDelete.getArtifactName()), artifactToNotDelete);
1638 artifacts.put("ignore", artifactToIgnore);
1640 resource.setDeploymentArtifacts(deploymentArtifacts);
1641 resource.setArtifacts(artifacts);
1643 List<NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
1644 NonMetaArtifactInfo deploymentArtifactInfoToUpdate = new NonMetaArtifactInfo(deploymentArtifactToUpdate.getArtifactName(), null,
1645 ArtifactTypeEnum.findType(deploymentArtifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1646 newPayloadData, deploymentArtifactToUpdate.getArtifactName(), false);
1648 NonMetaArtifactInfo informationalArtifactInfoToUpdate = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1649 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1650 newPayloadData, artifactToUpdate.getArtifactName(), false);
1652 NonMetaArtifactInfo informationalArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1653 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.INFORMATIONAL,
1654 newPayloadData, artifactToUpdate.getArtifactName(), true);
1656 NonMetaArtifactInfo deploymentArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1657 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1658 newPayloadData, artifactToUpdate.getArtifactName(), true);
1660 NonMetaArtifactInfo deploymentArtifactInfoToCreate = new NonMetaArtifactInfo(deploymentArtifactToCreateFileName, null,
1661 ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, deploymentArtifactToCreateFileName, false);
1663 NonMetaArtifactInfo informationalArtifactInfoToCreate = new NonMetaArtifactInfo(artifactInfoToCreateFileName, null,
1664 ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.INFORMATIONAL,
1665 newPayloadData, artifactInfoToCreateFileName, false);
1667 artifactPathAndNameList.add(deploymentArtifactInfoToUpdate);
1668 artifactPathAndNameList.add(informationalArtifactInfoToUpdate);
1669 artifactPathAndNameList.add(deploymentArtifactInfoToCreate);
1670 artifactPathAndNameList.add(informationalArtifactInfoToCreate);
1671 artifactPathAndNameList.add(informationalArtifactInfoToUpdateFromCsar);
1672 artifactPathAndNameList.add(deploymentArtifactInfoToUpdateFromCsar);
1674 Object[] argObjects = {resource, artifactPathAndNameList, user};
1675 Class[] argClasses = {Resource.class, List.class, User.class};
1677 Method method = targetClass.getDeclaredMethod(methodName, argClasses);
1678 method.setAccessible(true);
1679 Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes =
1680 (Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat>) method.invoke(bl, argObjects);
1681 assertTrue(findVfCsarArtifactsToHandleRes.isLeft());
1682 EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> foundVfArtifacts = findVfCsarArtifactsToHandleRes.left().value();
1683 assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.CREATE).size());
1684 assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.UPDATE).size());
1685 assertEquals(1, foundVfArtifacts.get(ArtifactOperationEnum.DELETE).size());
1687 } catch (Exception e) {
1688 e.printStackTrace();
1693 public void testVFGeneratedInputs() {
1694 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1695 Resource resource = createVF();
1696 List<InputDefinition> inputs = resource.getInputs();
1697 assertEquals(6, inputs.size());
1698 for (InputDefinition input : inputs) {
1699 assertThat(input.getOwnerId()).isNotNull();
1701 assertEquals(resource.getDerivedFromGenericType(), genericVF.getToscaResourceName());
1702 assertEquals(resource.getDerivedFromGenericVersion(), genericVF.getVersion());
1706 public void testCRGeneratedInputs() {
1707 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1708 Resource resource = createCR();
1709 List<InputDefinition> inputs = resource.getInputs();
1710 assertEquals(3, inputs.size());
1711 for (InputDefinition input : inputs) {
1712 assertThat(input.getOwnerId()).isNotNull();
1714 assertEquals(resource.getDerivedFromGenericType(), genericCR.getToscaResourceName());
1715 assertEquals(resource.getDerivedFromGenericVersion(), genericCR.getVersion());
1719 public void testVFUpdateGenericInputsToLatestOnCheckout() {
1720 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1721 //create a VF that is derived from generic version 1.0
1722 Resource resource = createVF();
1723 // create a new generic version without properties
1724 genericVF.setVersion("2.0");
1725 genericVF.setProperties(null);
1726 String currentDerivedFromVersion = resource.getDerivedFromGenericVersion();
1727 List<InputDefinition> currentInputs = resource.getInputs();
1728 //verify previous inputs ownerId fields exist - user may not delete generated inputs
1729 assertEquals(6, currentInputs.stream().filter(p -> null != p.getOwnerId()).collect(Collectors.toList()).size());
1730 Either<Boolean, ResponseFormat> upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource);
1732 assertTrue(upgradeToLatestGeneric.isLeft());
1733 //verify update required and valid
1734 assertTrue(upgradeToLatestGeneric.left().value());
1735 //verify version was upgraded
1736 assertNotEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion);
1737 //verify inputs were not deleted
1738 assertEquals(6, resource.getInputs().size());
1739 //verify inputs ownerId fields were removed - user may delete/edit inputs
1740 assertEquals(6, resource.getInputs()
1742 .filter(p -> null == p.getOwnerId())
1743 .collect(Collectors.toList())
1749 public void testVFUpdateGenericInputsToLatestOnCheckoutNotPerformed() {
1751 //create a VF that is derived from generic version 1.0
1752 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1753 Resource resource = createVF();
1755 //add an input to the VF
1756 PropertyDefinition newProp = new PropertyDefinition();
1757 newProp.setType("integer");
1758 newProp.setName("newProp");
1759 resource.getInputs().add(new InputDefinition(newProp));
1761 //create a new generic version with a new property which has the same name as a user defined input on the VF with a different type
1762 genericVF.setVersion("2.0");
1763 newProp.setType("string");
1764 genericVF.setProperties(new ArrayList<>());
1765 genericVF.getProperties().add(newProp);
1766 when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF));
1767 when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), genericVF.getUniqueId())).thenCallRealMethod();
1768 String currentDerivedFromVersion = resource.getDerivedFromGenericVersion();
1769 assertEquals(6, resource.getInputs()
1771 .filter(p -> null != p.getOwnerId())
1772 .collect(Collectors.toList())
1774 Either<Boolean, ResponseFormat> upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource);
1776 assertTrue(upgradeToLatestGeneric.isLeft());
1777 //verify update is invalid an void
1778 assertFalse(upgradeToLatestGeneric.left().value());
1779 //verify version was not upgraded
1780 assertEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion);
1781 //verify inputs were not removed
1782 assertEquals(7, resource.getInputs().size());
1783 //verify user defined input exists
1784 assertEquals(1, resource.getInputs()
1786 .filter(p -> null == p.getOwnerId())
1787 .collect(Collectors.toList())
1789 assertEquals("integer", resource.getInputs()
1791 .filter(p -> null == p.getOwnerId())
1798 public void testPNFGeneratedInputsNoGeneratedInformationalArtifacts() {
1799 validateUserRoles(Role.ADMIN, Role.DESIGNER);
1800 Resource resource = createPNF();
1801 List<InputDefinition> inputs = resource.getInputs();
1802 assertEquals(3, inputs.size());
1803 for (InputDefinition input : inputs) {
1804 assertThat(input.getOwnerId()).isNotNull();
1806 assertEquals(resource.getDerivedFromGenericType(), genericPNF.getToscaResourceName());
1807 assertEquals(resource.getDerivedFromGenericVersion(), genericPNF.getVersion());
1808 assertEquals(0, resource.getArtifacts().size());
1812 private Resource createVF() {
1814 genericVF = setupGenericTypeMock(GENERIC_VF_NAME);
1815 when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_VF_NAME)).thenReturn(Either.left(genericVF));
1816 Resource resource = createResourceObject(true);
1817 resource.setDerivedFrom(null);
1818 resource.setResourceType(ResourceTypeEnum.VF);
1819 when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1820 when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF));
1821 when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericVF)).thenCallRealMethod();
1822 when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1823 Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1824 assertThat(createdResource).isNotNull();
1825 return createdResource;
1829 private Resource createCR() {
1831 genericCR = setupGenericTypeMock(GENERIC_CR_NAME);
1832 when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_CR_NAME)).thenReturn(Either.left(genericCR));
1833 Resource resource = createResourceObject(true);
1834 resource.setDerivedFrom(null);
1835 resource.setResourceType(ResourceTypeEnum.CR);
1836 when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1837 when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericCR));
1838 when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericCR)).thenCallRealMethod();
1839 when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericCR.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1840 Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1841 assertThat(createdResource).isNotNull();
1842 return createdResource;
1845 private Resource createPNF() {
1847 genericPNF = setupGenericTypeMock(GENERIC_PNF_NAME);
1848 when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_PNF_NAME)).thenReturn(Either.left(genericPNF));
1849 Resource resource = createResourceObject(true);
1850 resource.setDerivedFrom(null);
1851 resource.setResourceType(ResourceTypeEnum.PNF);
1852 when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1853 when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericPNF));
1854 when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericPNF)).thenCallRealMethod();
1855 when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericPNF.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1856 Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1857 assertThat(createdResource).isNotNull();
1858 return createdResource;
1862 private Map<String, String> getGenericPropertiesByToscaName(String toscaName) {
1863 HashMap<String, String> PNFProps = new HashMap<String, String>() {{
1864 put("nf_function", "string");
1865 put("nf_role", "string");
1866 put("nf_type", "string");
1869 HashMap<String, String> CRProps = new HashMap<String, String>() {{
1870 put("cr_function", "string");
1871 put("cr_role", "string");
1872 put("cr_type", "string");
1875 HashMap<String, String> VFProps = new HashMap<String, String>() {{
1877 put("availability_zone_max_count", "integer");
1878 put("min_instances", "integer");
1879 put("max_instances", "integer");
1882 if (toscaName.contains("PNF")) return PNFProps;
1883 if (toscaName.contains("CR")) return CRProps;
1884 if (toscaName.contains("VF")) return VFProps;
1886 return new HashMap<>();
1890 private Resource setupGenericTypeMock(String toscaName) {
1892 Resource genericType = createResourceObject(true);
1893 genericType.setVersion("1.0");
1894 genericType.setToscaResourceName(toscaName);
1895 List<PropertyDefinition> genericProps = new ArrayList<>();
1896 Map<String, String> genericPropsMap = getGenericPropertiesByToscaName(toscaName);
1897 genericPropsMap.forEach((name, type) -> {
1898 PropertyDefinition prop = new PropertyDefinition();
1901 genericProps.add(prop);
1904 genericType.setProperties(genericProps);
1908 private void validateUserRoles(Role... roles) {
1909 List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
1914 public void testgetAllCertifiedResources() throws Exception {
1915 List<Resource> list = bl.getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, "USER");
1916 Assert.assertEquals(reslist,list);
1919 @Test(expected = StorageException.class)
1920 public void testgetAllCertifiedResources_exception() throws Exception {
1921 List<Resource> list = bl.getAllCertifiedResources(false, HighestFilterEnum.NON_HIGHEST_ONLY, "USER");
1922 Assert.assertEquals(reslist,list);
1926 public void testvalidateResourceNameExists() throws Exception {
1927 Either<Map<String, Boolean>, ResponseFormat> res = bl.validateResourceNameExists("Resource", ResourceTypeEnum.CR, "jh0003");
1928 Assert.assertEquals(true,res.isLeft());