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