catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.components.impl;
  24
  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.impl.exceptions.ByActionStatusComponentException;
  36 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  37 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  38 import org.openecomp.sdc.be.model.operations.StorageException;
  39 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
  40 import org.openecomp.sdc.be.components.csar.CsarInfo;
  41 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  42 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
  43 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  44 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  45 import org.openecomp.sdc.be.components.validation.UserValidations;
  46 import org.openecomp.sdc.be.config.ConfigurationManager;
  47 import org.openecomp.sdc.be.dao.api.ActionStatus;
  48 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  49 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  50 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  51 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  52 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  53 import org.openecomp.sdc.be.impl.ComponentsUtils;
  54 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  55 import org.openecomp.sdc.be.model.ArtifactDefinition;
  56 import org.openecomp.sdc.be.model.Component;
  57 import org.openecomp.sdc.be.model.DataTypeDefinition;
  58 import org.openecomp.sdc.be.model.InputDefinition;
  59 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
  60 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  61 import org.openecomp.sdc.be.model.PropertyDefinition;
  62 import org.openecomp.sdc.be.model.Resource;
  63 import org.openecomp.sdc.be.model.User;
  64 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  65 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
  66 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation;
  67 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation;
  68 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  69 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
  70 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  71 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  72 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  73 import org.openecomp.sdc.be.model.operations.impl.CacheMangerOperation;
  74 import org.openecomp.sdc.be.model.operations.impl.CsarOperation;
  75 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  76 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  77 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  78 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  79 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
  80 import org.openecomp.sdc.be.user.Role;
  81 import org.openecomp.sdc.be.user.UserBusinessLogic;
  82 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  83 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  84 import org.openecomp.sdc.common.api.ConfigurationSource;
  85 import org.openecomp.sdc.common.api.Constants;
  86 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  87 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  88 import org.openecomp.sdc.common.util.GeneralUtility;
  89 import org.openecomp.sdc.common.util.ValidationUtils;
  90 import org.openecomp.sdc.exception.ResponseFormat;
  91 import org.slf4j.Logger;
  92 import org.slf4j.LoggerFactory;
  93 import org.springframework.web.context.WebApplicationContext;
  94
  95 import javax.servlet.ServletContext;
  96 import java.io.IOException;
  97 import java.lang.reflect.Method;
  98 import java.util.ArrayList;
  99 import java.util.EnumMap;
 100 import java.util.HashMap;
 101 import java.util.List;
 102 import java.util.Map;
 103 import java.util.stream.Collectors;
 104 import java.util.stream.Stream;
 105
 106 import static org.junit.Assert.assertEquals;
 107 import static org.junit.Assert.assertFalse;
 108 import static org.junit.Assert.assertNotNull;
 109 import static org.junit.Assert.assertTrue;
 110 import static org.mockito.ArgumentMatchers.any;
 111 import static org.mockito.ArgumentMatchers.anyObject;
 112 import static org.mockito.ArgumentMatchers.anyString;
 113 import static org.mockito.ArgumentMatchers.eq;
 114 import static org.mockito.Mockito.when;
 115
 116 import static org.assertj.core.api.Java6Assertions.assertThat;
 117 import static org.junit.Assert.assertEquals;
 118 import static org.junit.Assert.assertFalse;
 119 import static org.junit.Assert.assertNotEquals;
 120 import static org.junit.Assert.assertNotNull;
 121 import static org.junit.Assert.assertTrue;
 122 import static org.mockito.ArgumentMatchers.any;
 123 import static org.mockito.ArgumentMatchers.eq;
 124 import static org.mockito.Mockito.times;
 125
 126 public class ResourceBusinessLogicTest {
 127
 128     private static final Logger log = LoggerFactory.getLogger(ResourceBusinessLogicTest.class);
 129     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 130     private static final String RESOURCE_SUBCATEGORY = "Router";
 131
 132     private static final String UPDATED_SUBCATEGORY = "Gateway";
 133
 134     private String resourceId = "resourceId1";
 135     private String operationId = "uniqueId1";
 136     Resource resourceUpdate;
 137
 138     private static final String RESOURCE_NAME = "My-Resource_Name with   space";
 139     private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
 140     private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF";
 141     private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR";
 142     private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF";
 143
 144     final ServletContext servletContext = Mockito.mock(ServletContext.class);
 145     IElementOperation mockElementDao;
 146     JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
 147     UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
 148     ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 149     NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class);
 150     NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class);
 151     TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
 152     final LifecycleBusinessLogic lifecycleBl = Mockito.mock(LifecycleBusinessLogic.class);
 153     final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class);
 154     final PropertyOperation propertyOperation = Mockito.mock(PropertyOperation.class);
 155     final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 156     WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
 157     UserValidations userValidations = Mockito.mock(UserValidations.class);
 158     WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
 159     IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class);
 160
 161     @InjectMocks
 162     ResourceBusinessLogic bl = new ResourceBusinessLogic();
 163     ResponseFormatManager responseManager = null;
 164     GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
 165     User user = null;
 166     Resource resourceResponse = null;
 167     Resource genericVF = null;
 168     Resource genericCR = null;
 169     Resource genericVFC = null;
 170     Resource genericPNF = null;
 171     ComponentsUtils componentsUtils;
 172     ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic();
 173     CsarOperation csarOperation = Mockito.mock(CsarOperation.class);
 174     @InjectMocks
 175     CsarBusinessLogic csarBusinessLogic = new CsarBusinessLogic();
 176     Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 177     private GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
 178     CacheMangerOperation cacheManager = Mockito.mock(CacheMangerOperation.class);
 179     List<Resource> reslist;
 180
 181     public ResourceBusinessLogicTest() {
 182     }
 183
 184     @Before
 185     public void setup() {
 186         MockitoAnnotations.initMocks(this);
 187         Mockito.reset(propertyOperation);
 188
 189         ExternalConfiguration.setAppName("catalog-be");
 190
 191         // init Configuration
 192         String appConfigDir = "src/test/resources/config/catalog-be";
 193         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 194         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 195         componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 196
 197         // Elements
 198         mockElementDao = new ElementOperationMock();
 199
 200         // User data and management
 201         user = new User();
 202         user.setUserId("jh0003");
 203         user.setFirstName("Jimmi");
 204         user.setLastName("Hendrix");
 205         user.setRole(Role.ADMIN.name());
 206
 207         Either<User, ActionStatus> eitherGetUser = Either.left(user);
 208         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
 209         when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).thenReturn(user);
 210         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 211         // Servlet Context attributes
 212         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 213         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 214         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 215         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 216
 217         Either<Integer, StorageOperationStatus> eitherCountRoot = Either.left(1);
 218         Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true);
 219         when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherFalse);
 220
 221
 222         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 223         when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
 224
 225         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 226         when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
 227         /*when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.VF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
 228         when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.PNF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
 229         when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);*/
 230         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
 231         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 232
 233         Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false);
 234         when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists);
 235         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 236         when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 237
 238         // createResource
 239         resourceResponse = createResourceObject(true);
 240         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 241         Either<Integer, StorageOperationStatus> eitherValidate = Either.left(null);
 242         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 243         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 244         when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 245         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 246
 247         // BL object
 248         artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
 249         bl = new ResourceBusinessLogic();
 250         bl.setElementDao(mockElementDao);
 251         bl.setUserAdmin(mockUserAdmin);
 252         bl.setCapabilityTypeOperation(capabilityTypeOperation);
 253         bl.setComponentsUtils(componentsUtils);
 254         bl.setLifecycleManager(lifecycleBl);
 255         bl.setGraphLockOperation(graphLockOperation);
 256         bl.setArtifactsManager(artifactManager);
 257         bl.setPropertyOperation(propertyOperation);
 258         bl.setJanusGraphGenericDao(mockJanusGraphDao);
 259         bl.setApplicationDataTypeCache(applicationDataTypeCache);
 260         bl.setCacheManagerOperation(cacheManager);
 261         bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic);
 262         toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation);
 263         toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation);
 264         bl.setToscaOperationFacade(toscaOperationFacade);
 265         bl.setUserValidations(userValidations);
 266         bl.setInterfaceTypeOperation(interfaceTypeOperation);
 267
 268         csarBusinessLogic.setCsarOperation(csarOperation);
 269         Resource resourceCsar = createResourceObjectCsar(true);
 270         setCanWorkOnResource(resourceCsar);
 271         Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar);
 272         when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes);
 273         responseManager = ResponseFormatManager.getInstance();
 274
 275         reslist = new ArrayList<Resource>();
 276         reslist.add(resourceResponse);
 277         reslist.add(genericVF);
 278         reslist.add(genericCR);
 279         reslist.add(genericVFC);
 280         reslist.add(genericPNF);
 281         Either<List<Resource>, StorageOperationStatus> returneval= Either.left(reslist);
 282         when(toscaOperationFacade.getAllCertifiedResources(true, true)).thenReturn(returneval);
 283         when(toscaOperationFacade.validateComponentNameUniqueness("Resource", ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(Either.left(true));
 284         Either<List<Resource>, StorageOperationStatus> returnevalexception= Either.right(StorageOperationStatus.BAD_REQUEST);
 285         when(toscaOperationFacade.getAllCertifiedResources(false, false)).thenReturn(returnevalexception);
 286
 287     }
 288
 289     private Resource createResourceObject(boolean afterCreate) {
 290         Resource resource = new Resource();
 291         resource.setName(RESOURCE_NAME);
 292         resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
 293         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 294         resource.setDescription("My short description");
 295         List<String> tgs = new ArrayList<>();
 296         tgs.add("test");
 297         tgs.add(resource.getName());
 298         resource.setTags(tgs);
 299         List<String> template = new ArrayList<>();
 300         template.add("Root");
 301         resource.setDerivedFrom(template);
 302         resource.setVendorName("Motorola");
 303         resource.setVendorRelease("1.0.0");
 304         resource.setContactId("ya5467");
 305         resource.setIcon("MyIcon");
 306
 307         if (afterCreate) {
 308             resource.setName(resource.getName());
 309             resource.setVersion("0.1");
 310             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 311             resource.setCreatorUserId(user.getUserId());
 312             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 313             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 314         }
 315         return resource;
 316     }
 317
 318     private Resource createResourceObjectCsar(boolean afterCreate) {
 319         Resource resource = new Resource();
 320         resource.setName(RESOURCE_NAME);
 321         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 322         resource.setDescription("My short description");
 323         List<String> tgs = new ArrayList<>();
 324         tgs.add("test");
 325         tgs.add(resource.getName());
 326         resource.setTags(tgs);
 327         List<String> template = new ArrayList<>();
 328         template.add("Root");
 329         resource.setDerivedFrom(template);
 330         resource.setVendorName("Motorola");
 331         resource.setVendorRelease("1.0.0");
 332         resource.setResourceVendorModelNumber("");
 333         resource.setContactId("ya5467");
 334         resource.setIcon("MyIcon");
 335         resource.setCsarUUID("valid_vf.csar");
 336         resource.setCsarVersion("1");
 337
 338         if (afterCreate) {
 339             resource.setName(resource.getName());
 340             resource.setVersion("0.1");
 341
 342             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 343             resource.setCreatorUserId(user.getUserId());
 344             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 345             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 346         }
 347         return resource;
 348     }
 349
 350     private Resource setCanWorkOnResource(Resource resource) {
 351         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 352         resource.setLastUpdaterUserId(user.getUserId());
 353         return resource;
 354     }
 355
 356     @Test
 357     public void testHappyScenario() {
 358         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 359         Resource resource = createResourceObject(false);
 360         Resource createdResource = null;
 361         try{
 362             createdResource= bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 363             assertThat(createResourceObject(true)).isEqualTo(createdResource);
 364         } catch(ByResponseFormatComponentException e){
 365             assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
 366         }
 367     }
 368
 369     @Test
 370     public void testUpdateHappyScenario() {
 371         Resource resource = createResourceObjectCsar(true);
 372         setCanWorkOnResource(resource);
 373         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 374         Either<Resource, StorageOperationStatus> resourceLinkedToCsarRes = Either.left(resource);
 375         when(toscaOperationFacade.getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, resource.getCsarUUID(), resource.getSystemName())).thenReturn(resourceLinkedToCsarRes);
 376         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
 377         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 378         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
 379         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
 380         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
 381         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
 382         Resource createdResource = null;
 383         try{
 384             createdResource= bl.validateAndUpdateResourceFromCsar(resource, user, null, null, resource.getUniqueId());
 385             assertThat(resource.getUniqueId()).isEqualTo(createdResource.getUniqueId());
 386         } catch(ByResponseFormatComponentException e){
 387             assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
 388         }
 389     }
 390
 391
 392     @Test
 393     public void testFailedResourceValidations() {
 394         testResourceNameExist();
 395         testResourceNameEmpty();
 396         // testResourceNameExceedsLimit();
 397         testResourceNameWrongFormat();
 398         testResourceDescExceedsLimitCreate();
 399         testResourceDescNotEnglish();
 400         testResourceDescriptionEmpty();
 401         testResourceDescriptionMissing();
 402         testResourceIconMissing();
 403         testResourceIconInvalid();
 404         testResourceIconExceedsLimit();
 405         testResourceTagNotExist();
 406         testResourceTagEmpty();
 407         testTagsExceedsLimitCreate();
 408         testTagsNoServiceName();
 409         testInvalidTag();
 410
 411         testContactIdTooLong();
 412         testContactIdWrongFormatCreate();
 413         testResourceContactIdEmpty();
 414         testResourceContactIdMissing();
 415         testVendorNameExceedsLimit();
 416         testVendorNameWrongFormatCreate();
 417         testVendorReleaseWrongFormat();
 418         testVendorReleaseExceedsLimitCreate();
 419         testResourceVendorModelNumberExceedsLimit();
 420         testResourceVendorNameMissing();
 421         testResourceVendorReleaseMissing();
 422         testResourceCategoryExist();
 423         testResourceBadCategoryCreate();
 424         testHappyScenarioCostLicenseType();
 425         testCostWrongFormatCreate();
 426         testLicenseTypeWrongFormatCreate();
 427         testResourceTemplateNotExist();
 428         testResourceTemplateEmpty();
 429         testResourceTemplateInvalid();
 430     }
 431
 432     private void testResourceNameExist() {
 433         String resourceName = "alreadyExists";
 434         Resource resourceExist = createResourceObject(false);
 435         resourceExist.setName(resourceName);
 436         resourceExist.getTags().add(resourceName);
 437         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 438         try {
 439             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 440         } catch (ByResponseFormatComponentException e) {
 441             assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resourceName);
 442         }
 443     }
 444
 445     private void testResourceNameEmpty() {
 446         Resource resourceExist = createResourceObject(false);
 447         resourceExist.setName(null);
 448
 449         try {
 450             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 451         } catch (ByActionStatusComponentException e) {
 452             assertComponentException(e, ActionStatus.MISSING_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
 453         }
 454     }
 455
 456     private void testResourceNameExceedsLimit() {
 457         Resource resourceExccedsNameLimit = createResourceObject(false);
 458         // 51 chars, the limit is 50
 459         String tooLongResourceName = "zCRCAWjqte0DtgcAAMmcJcXeNubeX1p1vOZNTShAHOYNAHvV3iK";
 460         resourceExccedsNameLimit.setName(tooLongResourceName);
 461
 462         try {
 463             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 464         } catch (ByActionStatusComponentException e) {
 465             assertComponentException(e, ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
 466         }
 467     }
 468
 469     private void testResourceNameWrongFormat() {
 470         Resource resource = createResourceObject(false);
 471         // contains :
 472         String nameWrongFormat = "ljg?fd";
 473         resource.setName(nameWrongFormat);
 474
 475         try {
 476             bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 477         } catch (ByActionStatusComponentException e) {
 478             assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
 479         }
 480     }
 481
 482     // Resource name - end
 483     // Resource description - start
 484     private void testResourceDescExceedsLimitCreate() {
 485         Resource resourceExccedsDescLimit = createResourceObject(false);
 486         // 1025 chars, the limit is 1024
 487         String tooLongResourceDesc = "1GUODojQ0sGzKR4NP7e5j82ADQ3KHTVOaezL95qcbuaqDtjZhAQGQ3iFwKAy580K4WiiXs3u3zq7RzXcSASl5fm0RsWtCMOIDP"
 488                 + "AOf9Tf2xtXxPCuCIMCR5wOGnNTaFxgnJEHAGxilBhZDgeMNHmCN1rMK5B5IRJOnZxcpcL1NeG3APTCIMP1lNAxngYulDm9heFSBc8TfXAADq7703AvkJT0QPpGq2z2P"
 489                 + "tlikcAnIjmWgfC5Tm7UH462BAlTyHg4ExnPPL4AO8c92VrD7kZSgSqiy73cN3gLT8uigkKrUgXQFGVUFrXVyyQXYtVM6bLBeuCGQf4C2j8lkNg6M0J3PC0PzMRoinOxk"
 490                 + "Ae2teeCtVcIj4A1KQo3210j8q2v7qQU69Mabsa6DT9FgE4rcrbiFWrg0Zto4SXWD3o1eJA9o29lTg6kxtklH3TuZTmpi5KVp1NFhS1RpnqF83tzv4mZLKsx7Zh1fEgYvRFwx1"
 491                 + "ar3RolyDfNoZiGBGTMsZzz7RPFBf2hTnLmNqVGQnHKhhGj0Y5s8t2cbqbO2nmHiJb9uaUVrCGypgbAcJL3KPOBfAVW8PcpmNj4yVjI3L4x5zHjmGZbp9vKshEQODcrmcgsYAoKqe"
 492                 + "uu5u7jk8XVxEfQ0m5qL8UOErXPlJovSmKUmP5B5T0w299zIWDYCzSoNasHpHjOMDLAiDDeHbozUOn9t3Qou00e9POq4RMM0VnIx1H38nJoJZz2XH8CI5YMQe7oTagaxgQTF2aa0qaq2"
 493                 + "V6nJsfRGRklGjNhFFYP2cS4Xv2IJO9DSX6LTXOmENrGVJJvMOZcvnBaZPfoAHN0LU4i1SoepLzulIxnZBfkUWFJgZ5wQ0Bco2GC1HMqzW21rwy4XHRxXpXbmW8LVyoA1KbnmVmROycU4"
 494                 + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
 495
 496         resourceExccedsDescLimit.setDescription(tooLongResourceDesc);
 497         try {
 498             bl.createResource(resourceExccedsDescLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 499         } catch (ByActionStatusComponentException e) {
 500             assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH);
 501         }
 502     }
 503
 504     private void testResourceDescNotEnglish() {
 505         Resource notEnglish = createResourceObject(false);
 506         // Not english
 507         String notEnglishDesc = "\uC2B5";
 508         notEnglish.setDescription(notEnglishDesc);
 509
 510         try {
 511             bl.createResource(notEnglish, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 512         } catch (ByActionStatusComponentException e) {
 513             assertComponentException(e, ActionStatus.COMPONENT_INVALID_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
 514         }
 515     }
 516
 517     private void testResourceDescriptionEmpty() {
 518         Resource resourceExist = createResourceObject(false);
 519         resourceExist.setDescription("");
 520
 521         try {
 522             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 523         } catch (ByActionStatusComponentException e) {
 524             assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
 525         }
 526     }
 527
 528     private void testResourceDescriptionMissing() {
 529         Resource resourceExist = createResourceObject(false);
 530         resourceExist.setDescription(null);
 531
 532         try {
 533             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 534         } catch (ByActionStatusComponentException e) {
 535             assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
 536         }
 537     }
 538     // Resource description - end
 539     // Resource icon start
 540
 541     private void testResourceIconMissing() {
 542         Resource resourceExist = createResourceObject(false);
 543         resourceExist.setIcon(null);
 544
 545         try {
 546             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 547         } catch (ByActionStatusComponentException e) {
 548             assertComponentException(e, ActionStatus.COMPONENT_MISSING_ICON, ComponentTypeEnum.RESOURCE.getValue());
 549         }
 550     }
 551
 552     private void testResourceIconInvalid() {
 553         Resource resourceExist = createResourceObject(false);
 554         resourceExist.setIcon("kjk3453^&");
 555
 556         try {
 557             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 558         } catch (ByActionStatusComponentException e) {
 559             assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue());
 560         }
 561     }
 562
 563     private void testResourceIconExceedsLimit() {
 564         Resource resourceExist = createResourceObject(false);
 565         resourceExist.setIcon("dsjfhskdfhskjdhfskjdhkjdhfkshdfksjsdkfhsdfsdfsdfsfsdfsf");
 566         try {
 567             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 568         } catch (ByActionStatusComponentException e) {
 569             assertComponentException(e, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.ICON_MAX_LENGTH);
 570         }
 571     }
 572
 573     // Resource icon end
 574     // Resource tags - start
 575     private void testResourceTagNotExist() {
 576         Resource resourceExist = createResourceObject(false);
 577         resourceExist.setTags(null);
 578         try {
 579             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 580         } catch (ByActionStatusComponentException e) {
 581             assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS);
 582         }
 583     }
 584
 585     private void testResourceTagEmpty() {
 586         Resource resourceExist = createResourceObject(false);
 587         resourceExist.setTags(new ArrayList<>());
 588         try {
 589             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 590         } catch (ByActionStatusComponentException e) {
 591             assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS);
 592         }
 593     }
 594
 595     private void testTagsExceedsLimitCreate() {
 596         Resource resourceExccedsNameLimit = createResourceObject(false);
 597         String tag1 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjQ";
 598         String tag2 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjW";
 599         String tag3 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjE";
 600         String tag4 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjb";
 601         String tag5 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjr";
 602         String tag6 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
 603         String tag7 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
 604         String tag8 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjd";
 605         String tag9 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
 606         String tag10 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
 607         String tag11 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjh";
 608         String tag12 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjj";
 609         String tag13 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjk";
 610         String tag14 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjs";
 611         String tag15 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjz";
 612         String tag16 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjx";
 613         String tag17 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj2";
 614         String tag18 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj3";
 615         String tag19 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj4";
 616         String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
 617         String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
 618
 619         List<String> tagsList = new ArrayList<>();
 620         tagsList.add(tag1);
 621         tagsList.add(tag2);
 622         tagsList.add(tag3);
 623         tagsList.add(tag4);
 624         tagsList.add(tag5);
 625         tagsList.add(tag6);
 626         tagsList.add(tag7);
 627         tagsList.add(tag8);
 628         tagsList.add(tag9);
 629         tagsList.add(tag10);
 630         tagsList.add(tag11);
 631         tagsList.add(tag12);
 632         tagsList.add(tag13);
 633         tagsList.add(tag14);
 634         tagsList.add(tag15);
 635         tagsList.add(tag16);
 636         tagsList.add(tag17);
 637         tagsList.add(tag18);
 638         tagsList.add(tag19);
 639         tagsList.add(tag20);
 640         tagsList.add(tag21);
 641         tagsList.add(resourceExccedsNameLimit.getName());
 642
 643         resourceExccedsNameLimit.setTags(tagsList);
 644         try {
 645             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 646         } catch (ByActionStatusComponentException e) {
 647             assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, "" + ValidationUtils.TAG_LIST_MAX_LENGTH);
 648         }
 649     }
 650
 651     private void testTagsSingleExceedsLimit() {
 652         Resource resourceExccedsNameLimit = createResourceObject(false);
 653         String tag1 = "afzs2qLBb5X6tZhiunkcEwiFX1qRQY8YZl3y3Du5M5xeQY5Nq9afcFHDZ9HaURw43gH27nAUWM36bMbMylwTFSzzNV8NO4v4ripe6Q15Vc2nPOFI";
 654         String tag2 = resourceExccedsNameLimit.getName();
 655         List<String> tagsList = new ArrayList<>();
 656         tagsList.add(tag1);
 657         tagsList.add(tag2);
 658
 659         resourceExccedsNameLimit.setTags(tagsList);
 660         try {
 661             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 662         } catch (ByActionStatusComponentException e) {
 663             assertComponentException(e, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT, "" + ValidationUtils.TAG_MAX_LENGTH);
 664         }
 665     }
 666
 667     private void testTagsNoServiceName() {
 668         Resource serviceExccedsNameLimit = createResourceObject(false);
 669         String tag1 = "afzs2qLBb";
 670         List<String> tagsList = new ArrayList<>();
 671         tagsList.add(tag1);
 672         serviceExccedsNameLimit.setTags(tagsList);
 673         try {
 674             bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 675         } catch (ByActionStatusComponentException e) {
 676             assertComponentException(e, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME);
 677         }
 678     }
 679
 680     private void testInvalidTag() {
 681         Resource serviceExccedsNameLimit = createResourceObject(false);
 682         String tag1 = "afzs2qLBb%#%";
 683         List<String> tagsList = new ArrayList<>();
 684         tagsList.add(tag1);
 685         serviceExccedsNameLimit.setTags(tagsList);
 686         try {
 687             bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 688         } catch (ByActionStatusComponentException e) {
 689             assertComponentException(e, ActionStatus.INVALID_FIELD_FORMAT, new String[]{"Resource", "tag"});
 690         }
 691     }
 692
 693     // Resource tags - stop
 694     // Resource contact start
 695
 696     private void testContactIdTooLong() {
 697         Resource resourceContactId = createResourceObject(false);
 698         // 59 chars instead of 50
 699         String contactIdTooLong = "thisNameIsVeryLongAndExeccedsTheNormalLengthForContactId";
 700         resourceContactId.setContactId(contactIdTooLong);
 701
 702         try {
 703             bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 704         } catch (ByActionStatusComponentException e) {
 705             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 706         }
 707     }
 708
 709     private void testContactIdWrongFormatCreate() {
 710         Resource resourceContactId = createResourceObject(false);
 711         // 3 letters and 3 digits and special characters
 712         String contactIdFormatWrong = "yrt134!!!";
 713         resourceContactId.setContactId(contactIdFormatWrong);
 714         try {
 715             bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 716         } catch (ByActionStatusComponentException e) {
 717             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 718         }
 719     }
 720
 721     private void testResourceContactIdEmpty() {
 722         Resource resourceExist = createResourceObject(false);
 723         resourceExist.setContactId("");
 724         try {
 725             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 726         } catch (ByActionStatusComponentException e) {
 727             assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 728         }
 729     }
 730
 731     private void testResourceContactIdMissing() {
 732         Resource resourceExist = createResourceObject(false);
 733         resourceExist.setContactId(null);
 734         try {
 735             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 736         } catch (ByActionStatusComponentException e) {
 737             assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 738         }
 739     }
 740
 741     private void testVendorNameExceedsLimit() {
 742         Resource resourceExccedsVendorNameLimit = createResourceObject(false);
 743         String tooLongVendorName = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
 744         resourceExccedsVendorNameLimit.setVendorName(tooLongVendorName);
 745         try {
 746             bl.createResource(resourceExccedsVendorNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 747         } catch (ByActionStatusComponentException e) {
 748             assertComponentException(e, ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
 749         }
 750     }
 751
 752     private void testResourceVendorModelNumberExceedsLimit() {
 753         Resource resourceExccedsVendorModelNumberLimit = createResourceObject(false);
 754         String tooLongVendorModelNumber = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
 755         resourceExccedsVendorModelNumberLimit.setResourceVendorModelNumber(tooLongVendorModelNumber);
 756         try {
 757             bl.createResource(resourceExccedsVendorModelNumberLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 758         } catch (ByActionStatusComponentException e) {
 759             assertComponentException(e, ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT, "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
 760         }
 761     }
 762
 763     private void testVendorNameWrongFormatCreate() {
 764         Resource resource = createResourceObject(false);
 765         // contains *
 766         String nameWrongFormat = "ljg*fd";
 767         resource.setVendorName(nameWrongFormat);
 768         try {
 769             bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 770         } catch (ByActionStatusComponentException e) {
 771             assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME);
 772         }
 773     }
 774
 775     private void testVendorReleaseWrongFormat() {
 776         Resource resource = createResourceObject(false);
 777         // contains >
 778         String nameWrongFormat = "1>2";
 779         resource.setVendorRelease(nameWrongFormat);
 780         try {
 781             bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 782         } catch (ByActionStatusComponentException e) {
 783             assertComponentException(e, ActionStatus.INVALID_VENDOR_RELEASE);
 784         }
 785     }
 786
 787     private void testVendorReleaseExceedsLimitCreate() {
 788         Resource resourceExccedsNameLimit = createResourceObject(false);
 789         String tooLongVendorRelease = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
 790         resourceExccedsNameLimit.setVendorRelease(tooLongVendorRelease);
 791         try {
 792             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 793         } catch (ByActionStatusComponentException e) {
 794             assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
 795         }
 796     }
 797
 798     private void testResourceVendorNameMissing() {
 799         Resource resourceExist = createResourceObject(false);
 800         resourceExist.setVendorName(null);
 801         try {
 802             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 803         } catch (ByActionStatusComponentException e) {
 804             assertComponentException(e, ActionStatus.MISSING_VENDOR_NAME);
 805         }
 806     }
 807
 808     private void testResourceVendorReleaseMissing() {
 809         Resource resourceExist = createResourceObject(false);
 810         resourceExist.setVendorRelease(null);
 811         try {
 812             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 813         } catch (ByActionStatusComponentException e) {
 814             assertComponentException(e, ActionStatus.MISSING_VENDOR_RELEASE);
 815         }
 816     }
 817
 818     // Resource vendor name/release stop
 819     // Category start
 820     private void testResourceCategoryExist() {
 821         Resource resourceExist = createResourceObject(false);
 822         resourceExist.setCategories(null);
 823         try {
 824             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 825         } catch (ByActionStatusComponentException e) {
 826             assertComponentException(e, ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
 827         }
 828     }
 829
 830     private void testResourceBadCategoryCreate() {
 831
 832         Resource resourceExist = createResourceObject(false);
 833         resourceExist.setCategories(null);
 834         resourceExist.addCategory("koko", "koko");
 835         try {
 836             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 837         } catch (ByActionStatusComponentException e) {
 838             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
 839         }
 840     }
 841
 842     // Category stop
 843     // Cost start
 844     private void testHappyScenarioCostLicenseType() {
 845         Resource createResourceObject = createResourceObject(false);
 846         Resource createResourceObjectAfterCreate = createResourceObject(true);
 847         // Adding cost and licenseType to basic mock
 848         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(createResourceObjectAfterCreate);
 849         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 850
 851         String cost = "123.456";
 852         String licenseType = "User";
 853         createResourceObject.setCost(cost);
 854         createResourceObject.setLicenseType(licenseType);
 855         Resource createdResource;
 856         try{
 857             createdResource = bl.createResource(createResourceObject, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 858             createResourceObjectAfterCreate.setCost(cost);
 859             createResourceObjectAfterCreate.setLicenseType(licenseType);
 860             assertThat(createResourceObjectAfterCreate).isEqualTo(createdResource);
 861         }catch(ByResponseFormatComponentException e){
 862             assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
 863         }
 864     }
 865
 866     private void testCostWrongFormatCreate() {
 867         Resource resourceCost = createResourceObject(false);
 868         // Comma instead of fullstop
 869         String cost = "12356,464";
 870         resourceCost.setCost(cost);
 871         try {
 872             bl.createResource(resourceCost, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 873         } catch (ByActionStatusComponentException e) {
 874             assertComponentException(e, ActionStatus.INVALID_CONTENT);
 875         }
 876     }
 877
 878     // Cost stop
 879     // License type start
 880     private void testLicenseTypeWrongFormatCreate() {
 881         Resource resourceLicenseType = createResourceObject(false);
 882         // lowcase
 883         String licenseType = "cpu";
 884         resourceLicenseType.setLicenseType(licenseType);
 885         try {
 886             bl.createResource(resourceLicenseType, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 887         } catch (ByActionStatusComponentException e) {
 888             assertComponentException(e, ActionStatus.INVALID_CONTENT);
 889         }
 890     }
 891
 892     // License type stop
 893     // Derived from start
 894     private void testResourceTemplateNotExist() {
 895         Resource resourceExist = createResourceObject(false);
 896         List<String> list = null;
 897         resourceExist.setDerivedFrom(list);
 898         try {
 899             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 900         } catch (ByActionStatusComponentException e) {
 901             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
 902         }
 903     }
 904
 905     private void testResourceTemplateEmpty() {
 906         Resource resourceExist = createResourceObject(false);
 907         resourceExist.setDerivedFrom(new ArrayList<>());
 908         try {
 909             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 910         } catch (ByActionStatusComponentException e) {
 911             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
 912         }
 913     }
 914
 915     private void testResourceTemplateInvalid() {
 916         Resource resourceExist = createResourceObject(false);
 917         ArrayList<String> derivedFrom = new ArrayList<>();
 918         derivedFrom.add("kuku");
 919         resourceExist.setDerivedFrom(derivedFrom);
 920         try {
 921             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 922         } catch (ByResponseFormatComponentException e) {
 923             assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
 924         } catch (ByActionStatusComponentException e) {
 925             assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
 926         }
 927     }
 928     // Derived from stop
 929     private void assertComponentException(ByResponseFormatComponentException e, ActionStatus expectedStatus, String... variables) {
 930         ResponseFormat actualResponse = e.getResponseFormat();
 931         assertResponse(actualResponse, expectedStatus, variables);
 932     }
 933
 934     private void assertComponentException(ByActionStatusComponentException e, ActionStatus expectedStatus, String... variables) {
 935         ResponseFormat actualResponse = componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 936         assertResponse(actualResponse, expectedStatus, variables);
 937     }
 938
 939     private void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
 940         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
 941         assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
 942         assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
 943     }
 944
 945     private void assertResponse(Either<Resource, ResponseFormat> createResponse, ActionStatus expectedStatus, String... variables) {
 946         assertResponse(createResponse.right().value(), expectedStatus, variables);
 947     }
 948
 949     // UPDATE tests - start
 950     // Resource name
 951     @Test
 952     public void testResourceNameWrongFormat_UPDATE() {
 953         Resource resource = createResourceObject(true);
 954         Resource updatedResource = createResourceObject(true);
 955
 956         // this is in order to prevent failing with 403 earlier
 957         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
 958         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
 959         // contains *
 960         String nameWrongFormat = "ljg*fd";
 961         updatedResource.setName(nameWrongFormat);
 962
 963         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
 964         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
 965         try {
 966             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
 967         } catch (ByActionStatusComponentException e) {
 968             assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
 969         }
 970     }
 971
 972     @Test
 973     public void testResourceNameAfterCertify_UPDATE() {
 974         Resource resource = createResourceObject(true);
 975         Resource updatedResource = createResourceObject(true);
 976
 977         // this is in order to prevent failing with 403 earlier
 978         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
 979         // when(resourceOperation.getResource_tx(resource.getUniqueId(),false)).thenReturn(eitherUpdate);
 980         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
 981
 982         String name = "ljg";
 983         updatedResource.setName(name);
 984         resource.setVersion("1.0");
 985
 986         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
 987         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
 988         try {
 989             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
 990         } catch (ByActionStatusComponentException e) {
 991             assertComponentException(e, ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED);
 992         }
 993     }
 994
 995     @Test
 996     public void testResourceNameAlreadyExist_UPDATE() {
 997         Resource resource = createResourceObject(true);
 998         Resource updatedResource = createResourceObject(true);
 999
1000         // this is in order to prevent failing with 403 earlier
1001         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1002         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1003
1004         String resourceName = "alreadyExists";
1005         updatedResource.setName(resourceName);
1006         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
1007         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1008         try {
1009             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1010         } catch (ByActionStatusComponentException e) {
1011             assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resourceName);
1012         }
1013     }
1014
1015     //
1016
1017     @Test
1018     public void testResourceDescExceedsLimit_UPDATE() {
1019         Resource resource = createResourceObject(true);
1020         Resource updatedResource = createResourceObject(true);
1021
1022         // this is in order to prevent failing with 403 earlier
1023         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1024         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1025
1026         // 1025 chars, the limit is 1024
1027         String tooLongResourceDesc = "1GUODojQ0sGzKR4NP7e5j82ADQ3KHTVOaezL95qcbuaqDtjZhAQGQ3iFwKAy580K4WiiXs3u3zq7RzXcSASl5fm0RsWtCMOIDP"
1028                 + "AOf9Tf2xtXxPCuCIMCR5wOGnNTaFxgnJEHAGxilBhZDgeMNHmCN1rMK5B5IRJOnZxcpcL1NeG3APTCIMP1lNAxngYulDm9heFSBc8TfXAADq7703AvkJT0QPpGq2z2P"
1029                 + "tlikcAnIjmWgfC5Tm7UH462BAlTyHg4ExnPPL4AO8c92VrD7kZSgSqiy73cN3gLT8uigkKrUgXQFGVUFrXVyyQXYtVM6bLBeuCGQf4C2j8lkNg6M0J3PC0PzMRoinOxk"
1030                 + "Ae2teeCtVcIj4A1KQo3210j8q2v7qQU69Mabsa6DT9FgE4rcrbiFWrg0Zto4SXWD3o1eJA9o29lTg6kxtklH3TuZTmpi5KVp1NFhS1RpnqF83tzv4mZLKsx7Zh1fEgYvRFwx1"
1031                 + "ar3RolyDfNoZiGBGTMsZzz7RPFBf2hTnLmNqVGQnHKhhGj0Y5s8t2cbqbO2nmHiJb9uaUVrCGypgbAcJL3KPOBfAVW8PcpmNj4yVjI3L4x5zHjmGZbp9vKshEQODcrmcgsYAoKqe"
1032                 + "uu5u7jk8XVxEfQ0m5qL8UOErXPlJovSmKUmP5B5T0w299zIWDYCzSoNasHpHjOMDLAiDDeHbozUOn9t3Qou00e9POq4RMM0VnIx1H38nJoJZz2XH8CI5YMQe7oTagaxgQTF2aa0qaq2"
1033                 + "V6nJsfRGRklGjNhFFYP2cS4Xv2IJO9DSX6LTXOmENrGVJJvMOZcvnBaZPfoAHN0LU4i1SoepLzulIxnZBfkUWFJgZ5wQ0Bco2GC1HMqzW21rwy4XHRxXpXbmW8LVyoA1KbnmVmROycU4"
1034                 + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
1035         updatedResource.setDescription(tooLongResourceDesc);
1036         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1037         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1038         try {
1039             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1040         } catch (ByActionStatusComponentException e) {
1041             assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH);
1042         }
1043     }
1044
1045     @Test
1046     public void testIconWrongFormat_UPDATE() {
1047         Resource resource = createResourceObject(true);
1048         Resource updatedResource = createResourceObject(true);
1049
1050         // this is in order to prevent failing with 403 earlier
1051         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1052         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1053
1054         // contains .
1055         String icon = "icon.jpg";
1056         updatedResource.setIcon(icon);
1057         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1058         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1059         try {
1060             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1061         } catch (ByActionStatusComponentException e) {
1062             assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue());
1063         }
1064     }
1065
1066     @Test
1067     public void testIconAfterCertify_UPDATE() {
1068         Resource resource = createResourceObject(true);
1069         Resource updatedResource = createResourceObject(true);
1070
1071         // this is in order to prevent failing with 403 earlier
1072         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1073         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1074
1075         // contains
1076         String icon = "icon";
1077         updatedResource.setIcon(icon);
1078
1079         resource.setVersion("1.0");
1080         ;
1081         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1082         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1083         try {
1084             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1085         } catch (ByActionStatusComponentException e) {
1086             assertComponentException(e, ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED);
1087         }
1088     }
1089
1090     @Test
1091     public void testTagsExceedsLimit_UPDATE() {
1092         Resource resource = createResourceObject(true);
1093         Resource updatedResource = createResourceObject(true);
1094
1095         // this is in order to prevent failing with 403 earlier
1096         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1097         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1098
1099         String tag1 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjQ";
1100         String tag2 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjW";
1101         String tag3 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjE";
1102         String tag4 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjb";
1103         String tag5 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjr";
1104         String tag6 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
1105         String tag7 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
1106         String tag8 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjd";
1107         String tag9 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
1108         String tag10 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
1109         String tag11 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjh";
1110         String tag12 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjj";
1111         String tag13 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjk";
1112         String tag14 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjs";
1113         String tag15 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjz";
1114         String tag16 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjx";
1115         String tag17 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj2";
1116         String tag18 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj3";
1117         String tag19 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj4";
1118         String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
1119         String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
1120
1121         List<String> tagsList = new ArrayList<>();
1122         tagsList.add(tag1);
1123         tagsList.add(tag2);
1124         tagsList.add(tag3);
1125         tagsList.add(tag4);
1126         tagsList.add(tag5);
1127         tagsList.add(tag6);
1128         tagsList.add(tag7);
1129         tagsList.add(tag8);
1130         tagsList.add(tag9);
1131         tagsList.add(tag10);
1132         tagsList.add(tag11);
1133         tagsList.add(tag12);
1134         tagsList.add(tag13);
1135         tagsList.add(tag14);
1136         tagsList.add(tag15);
1137         tagsList.add(tag16);
1138         tagsList.add(tag17);
1139         tagsList.add(tag18);
1140         tagsList.add(tag19);
1141         tagsList.add(tag20);
1142         tagsList.add(tag21);
1143         tagsList.add(resource.getName());
1144
1145         updatedResource.setTags(tagsList);
1146         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1147         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1148         try {
1149             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1150         } catch (ByActionStatusComponentException e) {
1151             assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, "" + ValidationUtils.TAG_LIST_MAX_LENGTH);
1152         }
1153     }
1154
1155     @Test
1156     public void testVendorNameWrongFormat_UPDATE() {
1157         Resource resource = createResourceObject(true);
1158         Resource updatedResource = createResourceObject(true);
1159
1160         // this is in order to prevent failing with 403 earlier
1161         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1162         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1163
1164         // contains *
1165         String nameWrongFormat = "ljg*fd";
1166         updatedResource.setVendorName(nameWrongFormat);
1167         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1168         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1169         try {
1170             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1171         } catch (ByActionStatusComponentException e) {
1172             assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME);
1173         }
1174     }
1175
1176     @Test
1177     public void testVendorNameWrongFormat() {
1178         Resource resource = createResourceObject(true);
1179         Resource updatedResource = createResourceObject(true);
1180
1181         // this is in order to prevent failing with 403 earlier
1182         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1183         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1184
1185         // contains *
1186         String nameWrongFormat = "ljg*fd";
1187         updatedResource.setVendorName(nameWrongFormat);
1188         resource.setVersion("1.0");
1189         ;
1190         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1191         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1192         try {
1193             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1194         } catch (ByActionStatusComponentException e) {
1195             assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME);
1196         }
1197     }
1198
1199     @Test
1200     public void testVendorReleaseExceedsLimit_UPDATE() {
1201         Resource resource = createResourceObject(true);
1202         Resource updatedResource = createResourceObject(true);
1203
1204         // this is in order to prevent failing with 403 earlier
1205         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1206         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1207         // 129 chars, the limit is 128
1208         String tooLongVendorRelease = "h1KSyJh9EspI8SPwAGu4VETfqWejeanuB1PCJBxJmJncYnrW0lnsEFFVRIukRJkwlOVnZCy8p38tjhANeZq3BGMHIawWR6ICl8Wi9mikRYALWgvJug00JrlQ0iPVKPLxy";
1209         updatedResource.setVendorRelease(tooLongVendorRelease);
1210         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1211         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1212         try {
1213             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1214         } catch (ByActionStatusComponentException e) {
1215             assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
1216         }
1217     }
1218
1219     @Test
1220     public void testResourceBadCategory_UPDATE() {
1221         Resource resource = createResourceObject(true);
1222         Resource updatedResource = createResourceObject(true);
1223
1224         // this is in order to prevent failing with 403 earlier
1225         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1226         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1227
1228         String resourceId = resource.getUniqueId();
1229         String badCategory = "ddfds";
1230         updatedResource.setCategories(null);
1231         updatedResource.addCategory(badCategory, "fikt");
1232         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1233         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1234         try {
1235             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1236         } catch (ByActionStatusComponentException e) {
1237             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
1238         }
1239     }
1240
1241     @Test
1242     public void testResourceCategoryAfterCertify_UPDATE() {
1243         Resource resource = createResourceObject(true);
1244         Resource updatedResource = createResourceObject(true);
1245
1246         // this is in order to prevent failing with 403 earlier
1247         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1248         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1249
1250         String resourceId = resource.getUniqueId();
1251         updatedResource.setCategories(null);
1252         updatedResource.addCategory(RESOURCE_CATEGORY1, UPDATED_SUBCATEGORY);
1253         resource.setVersion("1.0");
1254         ;
1255         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1256         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1257         try {
1258             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1259         } catch (ByActionStatusComponentException e) {
1260             assertComponentException(e, ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED);
1261         }
1262     }
1263
1264     // Derived from start
1265     @Test
1266     public void testResourceTemplateNotExist_UPDATE() {
1267         Resource resource = createResourceObject(true);
1268         Resource updatedResource = createResourceObject(true);
1269
1270         // this is in order to prevent failing with 403 earlier
1271         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1272         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1273         String resourceId = resource.getUniqueId();
1274
1275         List<String> list = null;
1276         updatedResource.setDerivedFrom(list);
1277         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1278         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1279         try {
1280             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1281         } catch (ByActionStatusComponentException e) {
1282             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
1283         }
1284     }
1285
1286     @Test
1287     public void testResourceTemplateEmpty_UPDATE() {
1288         Resource resource = createResourceObject(true);
1289         Resource updatedResource = createResourceObject(true);
1290         String resourceId = resource.getUniqueId();
1291
1292         // this is in order to prevent failing with 403 earlier
1293         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1294         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1295
1296         updatedResource.setDerivedFrom(new ArrayList<>());
1297         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1298         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1299         try {
1300             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1301         } catch (ByActionStatusComponentException e) {
1302             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
1303         }
1304     }
1305
1306     @Test
1307     public void testResourceTemplateInvalid_UPDATE() {
1308         Resource resource = createResourceObject(true);
1309         Resource updatedResource = createResourceObject(true);
1310         String resourceId = resource.getUniqueId();
1311
1312         // this is in order to prevent failing with 403 earlier
1313         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1314         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1315
1316         ArrayList<String> derivedFrom = new ArrayList<>();
1317         derivedFrom.add("kuku");
1318         updatedResource.setDerivedFrom(derivedFrom);
1319         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1320         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1321         try {
1322             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1323         } catch (ByActionStatusComponentException e) {
1324             assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
1325         }
1326     }
1327
1328     @Test
1329     public void testResourceTemplateCertify_UPDATE_HAPPY() {
1330         Resource resource = createResourceObject(true);
1331         Resource updatedResource = createResourceObject(true);
1332         String resourceId = resource.getUniqueId();
1333
1334         // this is in order to prevent failing with 403 earlier
1335         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1336         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1337
1338         Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(true);
1339         when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString())).thenReturn(isToscaNameExtending);
1340
1341         Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = Either.left(new HashMap<>());
1342         when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), Mockito.anyString())).thenReturn(findPropertiesOfNode);
1343
1344         resource.setVersion("1.0");
1345
1346         ArrayList<String> derivedFrom = new ArrayList<>();
1347         derivedFrom.add("tosca.nodes.Root");
1348         updatedResource.setDerivedFrom(derivedFrom);
1349         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
1350         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1351         Resource createdResource = bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1352         assertThat(createdResource).isNotNull();
1353     }
1354
1355     @Test
1356     public void testResourceTemplateCertify_UPDATE_SAD() {
1357         Resource resource = createResourceObject(true);
1358         Resource updatedResource = createResourceObject(true);
1359         String resourceId = resource.getUniqueId();
1360
1361         // this is in order to prevent failing with 403 earlier
1362         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1363         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1364
1365         Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(false);
1366         when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString()))
1367                 .thenReturn(isToscaNameExtending);
1368
1369         resource.setVersion("1.0");
1370
1371         ArrayList<String> derivedFrom = new ArrayList<>();
1372         derivedFrom.add("tosca.nodes.Root");
1373         updatedResource.setDerivedFrom(derivedFrom);
1374         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1375         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1376         Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = Either.left(new HashMap<>());
1377         when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), Mockito.anyString())).thenReturn(findPropertiesOfNode);
1378
1379         try {
1380             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1381         } catch (ByActionStatusComponentException e) {
1382             assertComponentException(e, ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND);
1383         }
1384     }
1385     // Derived from stop
1386
1387     @Test
1388     public void createOrUpdateResourceAlreadyCheckout() {
1389         Resource resourceExist = createResourceObject(false);
1390         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1391         Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1392         createdResource.setLastUpdaterUserId(user.getUserId());
1393         assertThat(createdResource).isNotNull();
1394         Either<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
1395         Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(createdResource);
1396         when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())).thenReturn(getCompLatestResult);
1397         when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(getLatestResult);
1398
1399         Resource resourceToUpdtae = createResourceObject(false);
1400
1401         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1402         assertNotNull(createOrUpdateResource);
1403
1404         Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1405         Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1406
1407     }
1408
1409     @Test
1410     public void createOrUpdateResourceCertified() {
1411         Resource resourceExist = createResourceObject(false);
1412         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1413         Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1414
1415         assertThat(createdResource).isNotNull();
1416         createdResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1417         createdResource.setVersion("1.0");
1418
1419         Either<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
1420         Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(createdResource);
1421         when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())).thenReturn(getCompLatestResult);        when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(getLatestResult);
1422
1423         when(lifecycleBl.changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean())).thenReturn(Either.left(createdResource));
1424
1425         Resource resourceToUpdtae = createResourceObject(false);
1426
1427         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1428         assertNotNull(createOrUpdateResource);
1429
1430         Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1431         Mockito.verify(lifecycleBl, Mockito.times(1)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1432
1433     }
1434
1435     @Test
1436     public void createOrUpdateResourceNotExist() {
1437         Resource resourceToUpdtae = createResourceObject(false);
1438
1439         Either<Component, StorageOperationStatus> getLatestResult = Either.right(StorageOperationStatus.NOT_FOUND);
1440         when(toscaOperationFacade.getLatestByName(resourceToUpdtae.getName())).thenReturn(getLatestResult);
1441
1442         Either<Component, StorageOperationStatus> getLatestToscaNameResult = Either.right(StorageOperationStatus.NOT_FOUND);
1443         when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdtae.getToscaResourceName())).thenReturn(getLatestToscaNameResult);
1444
1445         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1446         assertThat(createOrUpdateResource).isNotNull();
1447
1448         Mockito.verify(toscaOperationFacade, times(1)).createToscaComponent(eq(resourceToUpdtae));
1449         Mockito.verify(toscaOperationFacade, Mockito.times(0)).overrideComponent(any(Resource.class), any(Resource.class));
1450         Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1451
1452     }
1453
1454     @Test
1455     public void updateNestedResource_typeIsNew() throws IOException {
1456         Resource resourceToUpdate = createResourceObject(false);
1457         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc";
1458         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
1459         CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(),
1460                 RESOURCE_NAME, "template name", jsonContent, true);
1461         String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight();
1462         when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1463         when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1464         when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1465
1466         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo,
1467                 nodeName, false);
1468         assertThat(createOrUpdateResource).isNotNull();
1469
1470         Mockito.verify(toscaOperationFacade, times(1)).createToscaComponent(eq(resourceToUpdate));
1471         Mockito.verify(toscaOperationFacade, times(0)).overrideComponent(any(Resource.class), any(Resource.class));
1472         Mockito.verify(lifecycleBl, times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1473     }
1474
1475     @Test
1476     public void updateNestedResource_typeExists() throws IOException {
1477         Resource resourceToUpdate = createResourceObject(false);
1478         setCanWorkOnResource(resourceResponse);
1479         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc";
1480         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
1481         CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(),
1482                 RESOURCE_NAME, "template name", jsonContent, true);
1483         String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight();
1484         when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1485         when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1486         when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)).thenReturn(Either.left(resourceResponse));
1487         when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(Either.left(resourceResponse));
1488
1489         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo,
1490                 nodeName, false);
1491         assertThat(createOrUpdateResource).isNotNull();
1492         Mockito.verify(toscaOperationFacade, times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1493         Mockito.verify(lifecycleBl, times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1494     }
1495
1496     @Test
1497     public void testValidatePropertiesDefaultValues_SuccessfullWithoutProperties() {
1498         Resource basic = createResourceObject(true);
1499
1500         Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1501         assertTrue(validatePropertiesDefaultValues.isLeft());
1502     }
1503
1504     @Test
1505     public void testValidatePropertiesDefaultValues_SuccessfullWithProperties() {
1506         Resource basic = createResourceObject(true);
1507         PropertyDefinition property = new PropertyDefinition();
1508         property.setName("myProperty");
1509         property.setType(ToscaPropertyType.INTEGER.getType());
1510         property.setDefaultValue("1");
1511         List<PropertyDefinition> properties = new ArrayList<>();
1512         properties.add(property);
1513         basic.setProperties(properties);
1514         when(propertyOperation.isPropertyTypeValid(property)).thenReturn(true);
1515         when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(true);
1516         Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1517         assertTrue(validatePropertiesDefaultValues.isLeft());
1518     }
1519
1520     @Test
1521     public void testValidatePropertiesDefaultValues_FailedWithProperties() {
1522         Resource basic = createResourceObject(true);
1523         PropertyDefinition property = new PropertyDefinition();
1524         property.setName("myProperty");
1525         property.setType(ToscaPropertyType.INTEGER.getType());
1526         property.setDefaultValue("1.5");
1527         List<PropertyDefinition> properties = new ArrayList<>();
1528         properties.add(property);
1529         basic.setProperties(properties);
1530
1531         when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(false);
1532         Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1533         assertTrue(validatePropertiesDefaultValues.isRight());
1534     }
1535
1536
1537     @SuppressWarnings("unchecked")
1538     @Test
1539     public void testFindVfCsarArtifactsToHandle() {
1540
1541         Class<ResourceBusinessLogic> targetClass = ResourceBusinessLogic.class;
1542         String methodName = "findVfCsarArtifactsToHandle";
1543         Resource resource = new Resource();
1544         String deploymentArtifactToUpdateFileName = "deploymentArtifactToUpdate.yaml";
1545         String deploymentArtifactToDeleteFileName = "deploymentArtifactToDelete.yaml";
1546         String deploymentArtifactToCreateFileName = "deploymentArtifactToCreate.yaml";
1547
1548         String artifactInfoToUpdateFileName = "infoArtifactToUpdate.yaml";
1549         String artifactInfoToDeleteFileName = "infoArtifactToDelete.yaml";
1550         String artifactInfoToNotDeleteFileName = "infoArtifactNotToDelete.yaml";
1551         String artifactInfoToCreateFileName = "infoArtifactToCreate.yaml";
1552
1553         byte[] oldPayloadData = "oldPayloadData".getBytes();
1554         byte[] newPayloadData = "newPayloadData".getBytes();
1555         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
1556
1557         ArtifactDefinition deploymentArtifactToUpdate = new ArtifactDefinition();
1558         deploymentArtifactToUpdate.setMandatory(false);
1559         deploymentArtifactToUpdate.setArtifactName(deploymentArtifactToUpdateFileName);
1560         deploymentArtifactToUpdate.setArtifactType("SNMP_POLL");
1561         deploymentArtifactToUpdate.setPayload(oldPayloadData);
1562         deploymentArtifactToUpdate.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1563
1564         ArtifactDefinition deploymentArtifactToDelete = new ArtifactDefinition();
1565         deploymentArtifactToDelete.setMandatory(false);
1566         deploymentArtifactToDelete.setArtifactName(deploymentArtifactToDeleteFileName);
1567         deploymentArtifactToDelete.setArtifactType("SNMP_TRAP");
1568         deploymentArtifactToDelete.setPayload(oldPayloadData);
1569         deploymentArtifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1570
1571         ArtifactDefinition deploymentArtifactToIgnore = new ArtifactDefinition();
1572
1573         deploymentArtifacts.put(ValidationUtils.normalizeArtifactLabel(deploymentArtifactToUpdate.getArtifactName()), deploymentArtifactToUpdate);
1574         deploymentArtifacts.put(ValidationUtils.normalizeArtifactLabel(deploymentArtifactToDelete.getArtifactName()), deploymentArtifactToDelete);
1575         deploymentArtifacts.put("ignore", deploymentArtifactToIgnore);
1576
1577         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1578
1579         ArtifactDefinition artifactToUpdate = new ArtifactDefinition();
1580         artifactToUpdate.setMandatory(false);
1581         artifactToUpdate.setArtifactName(artifactInfoToUpdateFileName);
1582         artifactToUpdate.setArtifactType("SNMP_POLL");
1583         artifactToUpdate.setPayload(oldPayloadData);
1584         artifactToUpdate.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1585
1586         ArtifactDefinition artifactToDelete = new ArtifactDefinition();
1587         artifactToDelete.setMandatory(false);
1588         artifactToDelete.setArtifactName(artifactInfoToDeleteFileName);
1589         artifactToDelete.setArtifactType("SNMP_TRAP");
1590         artifactToDelete.setPayload(oldPayloadData);
1591         artifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1592         artifactToDelete.setIsFromCsar(true);
1593
1594         ArtifactDefinition artifactToNotDelete = new ArtifactDefinition();
1595         artifactToNotDelete.setMandatory(false);
1596         artifactToNotDelete.setArtifactName(artifactInfoToNotDeleteFileName);
1597         artifactToNotDelete.setArtifactType("SNMP_TRAP");
1598         artifactToNotDelete.setPayload(oldPayloadData);
1599         artifactToNotDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1600         artifactToNotDelete.setIsFromCsar(false);
1601
1602         ArtifactDefinition artifactToIgnore = new ArtifactDefinition();
1603
1604         artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToUpdate.getArtifactName()), artifactToUpdate);
1605         artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToDelete.getArtifactName()), artifactToDelete);
1606         artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToNotDelete.getArtifactName()), artifactToNotDelete);
1607         artifacts.put("ignore", artifactToIgnore);
1608
1609         resource.setDeploymentArtifacts(deploymentArtifacts);
1610         resource.setArtifacts(artifacts);
1611
1612         List<NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
1613         NonMetaArtifactInfo deploymentArtifactInfoToUpdate = new NonMetaArtifactInfo(deploymentArtifactToUpdate.getArtifactName(), null,
1614                 ArtifactTypeEnum.findType(deploymentArtifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1615                 newPayloadData, deploymentArtifactToUpdate.getArtifactName(), false);
1616
1617         NonMetaArtifactInfo informationalArtifactInfoToUpdate = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1618                 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1619                 newPayloadData, artifactToUpdate.getArtifactName(), false);
1620
1621         NonMetaArtifactInfo informationalArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1622                 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.INFORMATIONAL,
1623                 newPayloadData, artifactToUpdate.getArtifactName(), true);
1624
1625         NonMetaArtifactInfo deploymentArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1626                 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1627                 newPayloadData, artifactToUpdate.getArtifactName(), true);
1628
1629         NonMetaArtifactInfo deploymentArtifactInfoToCreate = new NonMetaArtifactInfo(deploymentArtifactToCreateFileName, null,
1630                 ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, deploymentArtifactToCreateFileName, false);
1631
1632         NonMetaArtifactInfo informationalArtifactInfoToCreate = new NonMetaArtifactInfo(artifactInfoToCreateFileName, null,
1633                 ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.INFORMATIONAL,
1634                 newPayloadData, artifactInfoToCreateFileName, false);
1635
1636         artifactPathAndNameList.add(deploymentArtifactInfoToUpdate);
1637         artifactPathAndNameList.add(informationalArtifactInfoToUpdate);
1638         artifactPathAndNameList.add(deploymentArtifactInfoToCreate);
1639         artifactPathAndNameList.add(informationalArtifactInfoToCreate);
1640         artifactPathAndNameList.add(informationalArtifactInfoToUpdateFromCsar);
1641         artifactPathAndNameList.add(deploymentArtifactInfoToUpdateFromCsar);
1642
1643         Object[] argObjects = {resource, artifactPathAndNameList, user};
1644         Class[] argClasses = {Resource.class, List.class, User.class};
1645         try {
1646             Method method = targetClass.getDeclaredMethod(methodName, argClasses);
1647             method.setAccessible(true);
1648             Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes =
1649                     (Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat>) method.invoke(bl, argObjects);
1650             assertTrue(findVfCsarArtifactsToHandleRes.isLeft());
1651             EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> foundVfArtifacts = findVfCsarArtifactsToHandleRes.left().value();
1652             assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.CREATE).size());
1653             assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.UPDATE).size());
1654             assertEquals(1, foundVfArtifacts.get(ArtifactOperationEnum.DELETE).size());
1655
1656         } catch (Exception e) {
1657             e.printStackTrace();
1658         }
1659     }
1660
1661     @Test
1662     public void testVFGeneratedInputs() {
1663         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1664         Resource resource = createVF();
1665         List<InputDefinition> inputs = resource.getInputs();
1666         assertEquals(6, inputs.size());
1667         for (InputDefinition input : inputs) {
1668             assertThat(input.getOwnerId()).isNotNull();
1669         }
1670         assertEquals(resource.getDerivedFromGenericType(), genericVF.getToscaResourceName());
1671         assertEquals(resource.getDerivedFromGenericVersion(), genericVF.getVersion());
1672     }
1673
1674     @Test
1675     public void testCRGeneratedInputs() {
1676         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1677         Resource resource = createCR();
1678         List<InputDefinition> inputs = resource.getInputs();
1679         assertEquals(3, inputs.size());
1680         for (InputDefinition input : inputs) {
1681             assertThat(input.getOwnerId()).isNotNull();
1682         }
1683         assertEquals(resource.getDerivedFromGenericType(), genericCR.getToscaResourceName());
1684         assertEquals(resource.getDerivedFromGenericVersion(), genericCR.getVersion());
1685     }
1686
1687     @Test
1688     public void testVFUpdateGenericInputsToLatestOnCheckout() {
1689         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1690         //create a VF that is derived from generic version 1.0
1691         Resource resource = createVF();
1692         // create a new generic version without properties
1693         genericVF.setVersion("2.0");
1694         genericVF.setProperties(null);
1695         String currentDerivedFromVersion = resource.getDerivedFromGenericVersion();
1696         List<InputDefinition> currentInputs = resource.getInputs();
1697         //verify previous inputs ownerId fields exist - user may not delete generated inputs
1698         assertEquals(6, currentInputs.stream().filter(p -> null != p.getOwnerId()).collect(Collectors.toList()).size());
1699         Either<Boolean, ResponseFormat> upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource);
1700         //verify success
1701         assertTrue(upgradeToLatestGeneric.isLeft());
1702         //verify update required and valid
1703         assertTrue(upgradeToLatestGeneric.left().value());
1704         //verify version was upgraded
1705         assertNotEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion);
1706         //verify inputs were not deleted
1707         assertEquals(6, resource.getInputs().size());
1708         //verify inputs ownerId fields were removed - user may delete/edit inputs
1709         assertEquals(6, resource.getInputs()
1710                                 .stream()
1711                                 .filter(p -> null == p.getOwnerId())
1712                                 .collect(Collectors.toList())
1713                                 .size());
1714     }
1715
1716
1717     @Test
1718     public void testVFUpdateGenericInputsToLatestOnCheckoutNotPerformed() {
1719
1720         //create a VF that is derived from generic version 1.0
1721         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1722         Resource resource = createVF();
1723
1724         //add an input to the VF
1725         PropertyDefinition newProp = new PropertyDefinition();
1726         newProp.setType("integer");
1727         newProp.setName("newProp");
1728         resource.getInputs().add(new InputDefinition(newProp));
1729
1730         //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
1731         genericVF.setVersion("2.0");
1732         newProp.setType("string");
1733         genericVF.setProperties(new ArrayList<>());
1734         genericVF.getProperties().add(newProp);
1735         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF));
1736         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), genericVF.getUniqueId())).thenCallRealMethod();
1737         String currentDerivedFromVersion = resource.getDerivedFromGenericVersion();
1738         assertEquals(6, resource.getInputs()
1739                                 .stream()
1740                                 .filter(p -> null != p.getOwnerId())
1741                                 .collect(Collectors.toList())
1742                                 .size());
1743         Either<Boolean, ResponseFormat> upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource);
1744         //verify success
1745         assertTrue(upgradeToLatestGeneric.isLeft());
1746         //verify update is invalid an void
1747         assertFalse(upgradeToLatestGeneric.left().value());
1748         //verify version was not upgraded
1749         assertEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion);
1750         //verify inputs were not removed
1751         assertEquals(7, resource.getInputs().size());
1752         //verify user defined input exists
1753         assertEquals(1, resource.getInputs()
1754                                 .stream()
1755                                 .filter(p -> null == p.getOwnerId())
1756                                 .collect(Collectors.toList())
1757                                 .size());
1758         assertEquals("integer", resource.getInputs()
1759                                         .stream()
1760                                         .filter(p -> null == p.getOwnerId())
1761                                         .findAny()
1762                                         .get()
1763                                         .getType());
1764     }
1765
1766     @Test
1767     public void testPNFGeneratedInputsNoGeneratedInformationalArtifacts() {
1768         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1769         Resource resource = createPNF();
1770         List<InputDefinition> inputs = resource.getInputs();
1771         assertEquals(3, inputs.size());
1772         for (InputDefinition input : inputs) {
1773             assertThat(input.getOwnerId()).isNotNull();
1774         }
1775         assertEquals(resource.getDerivedFromGenericType(), genericPNF.getToscaResourceName());
1776         assertEquals(resource.getDerivedFromGenericVersion(), genericPNF.getVersion());
1777         assertEquals(0, resource.getArtifacts().size());
1778     }
1779
1780
1781     private Resource createVF() {
1782
1783         genericVF = setupGenericTypeMock(GENERIC_VF_NAME);
1784         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_VF_NAME)).thenReturn(Either.left(genericVF));
1785         Resource resource = createResourceObject(true);
1786         resource.setDerivedFrom(null);
1787         resource.setResourceType(ResourceTypeEnum.VF);
1788         when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1789         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF));
1790         when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericVF)).thenCallRealMethod();
1791         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1792         Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1793         assertThat(createdResource).isNotNull();
1794         return createdResource;
1795     }
1796
1797
1798     private Resource createCR() {
1799
1800         genericCR = setupGenericTypeMock(GENERIC_CR_NAME);
1801         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_CR_NAME)).thenReturn(Either.left(genericCR));
1802         Resource resource = createResourceObject(true);
1803         resource.setDerivedFrom(null);
1804         resource.setResourceType(ResourceTypeEnum.CR);
1805         when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1806         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericCR));
1807         when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericCR)).thenCallRealMethod();
1808         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericCR.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1809         Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1810         assertThat(createdResource).isNotNull();
1811         return createdResource;
1812     }
1813
1814     private Resource createPNF() {
1815
1816         genericPNF = setupGenericTypeMock(GENERIC_PNF_NAME);
1817         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_PNF_NAME)).thenReturn(Either.left(genericPNF));
1818         Resource resource = createResourceObject(true);
1819         resource.setDerivedFrom(null);
1820         resource.setResourceType(ResourceTypeEnum.PNF);
1821         when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1822         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericPNF));
1823         when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericPNF)).thenCallRealMethod();
1824         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericPNF.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1825         Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1826         assertThat(createdResource).isNotNull();
1827         return createdResource;
1828     }
1829
1830
1831     private Map<String, String> getGenericPropertiesByToscaName(String toscaName) {
1832         HashMap<String, String> PNFProps = new HashMap<String, String>() {{
1833             put("nf_function", "string");
1834             put("nf_role", "string");
1835             put("nf_type", "string");
1836         }};
1837
1838         HashMap<String, String> CRProps = new HashMap<String, String>() {{
1839             put("cr_function", "string");
1840             put("cr_role", "string");
1841             put("cr_type", "string");
1842         }};
1843
1844         HashMap<String, String> VFProps = new HashMap<String, String>() {{
1845             putAll(CRProps);
1846             put("availability_zone_max_count", "integer");
1847             put("min_instances", "integer");
1848             put("max_instances", "integer");
1849         }};
1850
1851         if (toscaName.contains("PNF")) return PNFProps;
1852         if (toscaName.contains("CR")) return CRProps;
1853         if (toscaName.contains("VF")) return VFProps;
1854
1855         return new HashMap<>();
1856     }
1857
1858
1859     private Resource setupGenericTypeMock(String toscaName) {
1860
1861         Resource genericType = createResourceObject(true);
1862         genericType.setVersion("1.0");
1863         genericType.setToscaResourceName(toscaName);
1864         List<PropertyDefinition> genericProps = new ArrayList<>();
1865         Map<String, String> genericPropsMap = getGenericPropertiesByToscaName(toscaName);
1866         genericPropsMap.forEach((name, type) -> {
1867             PropertyDefinition prop = new PropertyDefinition();
1868             prop.setName(name);
1869             prop.setType(type);
1870             genericProps.add(prop);
1871         });
1872
1873         genericType.setProperties(genericProps);
1874         return genericType;
1875     }
1876
1877     private void validateUserRoles(Role... roles) {
1878         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
1879     }
1880
1881
1882     @Test
1883     public void testgetAllCertifiedResources() throws Exception {
1884         List<Resource> list = bl.getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, "USER");
1885         Assert.assertEquals(reslist,list);
1886     }
1887
1888     @Test(expected = StorageException.class)
1889     public void testgetAllCertifiedResources_exception() throws Exception {
1890         List<Resource> list = bl.getAllCertifiedResources(false, HighestFilterEnum.NON_HIGHEST_ONLY, "USER");
1891         Assert.assertEquals(reslist,list);
1892     }
1893
1894     @Test
1895     public void testvalidateResourceNameExists() throws Exception {
1896         Either<Map<String, Boolean>, ResponseFormat> res = bl.validateResourceNameExists("Resource", ResourceTypeEnum.CR, "jh0003");
1897         Assert.assertEquals(true,res.isLeft());
1898     }
1899
1900
1901 }