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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.be.components.impl;
  18
  19 import static org.mockito.ArgumentMatchers.any;
  20 import static org.mockito.ArgumentMatchers.anyBoolean;
  21 import static org.mockito.ArgumentMatchers.anyCollection;
  22 import static org.mockito.ArgumentMatchers.anyObject;
  23 import static org.mockito.ArgumentMatchers.anyString;
  24 import static org.mockito.ArgumentMatchers.eq;
  25 import static org.mockito.Mockito.when;
  26
  27 import fj.data.Either;
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.stream.Collectors;
  33 import java.util.stream.Stream;
  34 import javax.servlet.ServletContext;
  35 import org.junit.Assert;
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.mockito.InjectMocks;
  39 import org.mockito.Mockito;
  40 import org.mockito.MockitoAnnotations;
  41 import org.openecomp.sdc.ElementOperationMock;
  42 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  43 import org.openecomp.sdc.be.components.validation.InterfaceOperationValidation;
  44 import org.openecomp.sdc.be.components.validation.UserValidations;
  45 import org.openecomp.sdc.be.config.ConfigurationManager;
  46 import org.openecomp.sdc.be.dao.api.ActionStatus;
  47 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  48 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  49 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  50 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  51 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  52 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  53 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  54 import org.openecomp.sdc.be.impl.ComponentsUtils;
  55 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  56 import org.openecomp.sdc.be.model.Component;
  57 import org.openecomp.sdc.be.model.DataTypeDefinition;
  58 import org.openecomp.sdc.be.model.InterfaceDefinition;
  59 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  60 import org.openecomp.sdc.be.model.Operation;
  61 import org.openecomp.sdc.be.model.Resource;
  62 import org.openecomp.sdc.be.model.User;
  63 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  64 import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
  65 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
  66 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation;
  67 import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
  68 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  69 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  70 import org.openecomp.sdc.be.model.operations.api.IPropertyOperation;
  71 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  72 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  73 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  74 import org.openecomp.sdc.be.user.Role;
  75 import org.openecomp.sdc.be.user.UserBusinessLogic;
  76 import org.openecomp.sdc.common.api.ConfigurationSource;
  77 import org.openecomp.sdc.common.api.Constants;
  78 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  79 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  80 import org.openecomp.sdc.exception.ResponseFormat;
  81 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
  82 import org.springframework.web.context.WebApplicationContext;
  83
  84 public class InterfaceOperationBusinessLogicTest {
  85
  86     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
  87     private static final String RESOURCE_SUBCATEGORY = "Router";
  88
  89     private final String resourceId = "resourceId1";
  90     private final String operationId = "uniqueId1";
  91     private Operation operation;
  92
  93     private static final String RESOURCE_NAME = "Resource1";
  94
  95     private final ServletContext servletContext = Mockito.mock(ServletContext.class);
  96     private final TitanDao mockTitanDao = Mockito.mock(TitanDao.class);
  97     private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
  98     private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
  99     private final NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class);
 100     private final NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class);
 101     private final TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
 102     private final IPropertyOperation propertyOperation = Mockito.mock(IPropertyOperation.class);
 103     private final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 104     private final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
 105     private final UserValidations userValidations = Mockito.mock(UserValidations.class);
 106     private final WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
 107     private final ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class);
 108     private final InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class);
 109     private final InterfaceOperationValidation operationValidator = Mockito.mock(InterfaceOperationValidation.class);
 110     private InterfaceLifecycleOperation interfaceLifecycleOperation = Mockito.mock(InterfaceLifecycleOperation.class);
 111
 112     private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
 113     private User user = null;
 114     private final ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic();
 115
 116     @InjectMocks
 117     private
 118     InterfaceOperationBusinessLogic bl = new InterfaceOperationBusinessLogic();
 119
 120     @Before
 121     public void setup() {
 122         MockitoAnnotations.initMocks(this);
 123         Mockito.reset(propertyOperation);
 124
 125         ExternalConfiguration.setAppName("catalog-be");
 126
 127         // init Configuration
 128         String appConfigDir = "src/test/resources/config/catalog-be";
 129         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 130         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 131         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 132
 133         // Elements
 134         IElementOperation mockElementDao = new ElementOperationMock();
 135
 136         // User data and management
 137         user = new User();
 138         user.setUserId("jh0003");
 139         user.setFirstName("Jimmi");
 140         user.setLastName("Hendrix");
 141         user.setRole(Role.ADMIN.name());
 142
 143         Either<User, ActionStatus> eitherGetUser = Either.left(user);
 144         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
 145         when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).thenReturn(user);
 146         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 147         // Servlet Context attributes
 148         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 149         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 150         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 151         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 152
 153         Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true);
 154         when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherFalse);
 155
 156         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 157         when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
 158
 159         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 160         when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
 161
 162         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
 163         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 164
 165         Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false);
 166         when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists);
 167         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 168         when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 169
 170         // createResource
 171         Resource resourceResponse = createResourceObject(true);
 172         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 173         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 174         //TODO Remove if passes
 175         /*when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate);*/
 176         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 177         when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 178
 179         //InterfaceOperation
 180         when(operationValidator.validateInterfaceOperations(anyCollection(), anyObject(), anyBoolean())).thenReturn(Either.left(true));
 181         when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK);
 182
 183         // BL object
 184         artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
 185         bl = new InterfaceOperationBusinessLogic();
 186
 187         bl.setUserAdmin(mockUserAdmin);
 188         bl.setComponentsUtils(componentsUtils);
 189         bl.setGraphLockOperation(graphLockOperation);
 190         bl.setTitanGenericDao(mockTitanDao);
 191         toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation);
 192         toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation);
 193         bl.setToscaOperationFacade(toscaOperationFacade);
 194         bl.setUserValidations(userValidations);
 195         bl.setInterfaceOperation(interfaceOperation);
 196         bl.setInterfaceOperationValidation(operationValidator);
 197         bl.setInterfaceLifecycleOperation(interfaceLifecycleOperation);
 198         Resource resourceCsar = createResourceObjectCsar(true);
 199         setCanWorkOnResource(resourceCsar);
 200         Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar);
 201         when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes);
 202     }
 203
 204     @Test
 205     public void createInterfaceOperationTest() {
 206         Resource resource = createResourceForInterfaceOperation();
 207         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 208         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 209         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 210         operation = InterfaceOperationTestUtils.createMockOperation();
 211         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 212
 213         Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
 214         Assert.assertTrue(interfaceOperation.isLeft());
 215         Assert.assertNotNull(interfaceOperation.left().value().getWorkflowId());
 216         Assert.assertNotNull(interfaceOperation.left().value().getWorkflowVersionId());
 217     }
 218
 219     @Test
 220     public void createInterfaceOperationWithoutInterfaceTest() {
 221         Resource resource = createResourceObjectCsar(true);
 222         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 223         resource.setInterfaces(new HashMap<>());
 224         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 225         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 226         operation = InterfaceOperationTestUtils.createMockOperation();
 227         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 228         when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.left(new InterfaceDefinition()));
 229
 230         Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
 231         Assert.assertTrue(interfaceOperation.isLeft());
 232
 233     }
 234
 235     @Test
 236     public void shouldFailCreateInterfaceOperationWhenCreateOperationFailedTest() {
 237         Resource resource = createResourceObjectCsar(true);
 238         resource.setInterfaces(new HashMap<>());
 239         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 240         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 241         operation = InterfaceOperationTestUtils.createMockOperation();
 242         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 243         when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 244
 245         Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
 246         Assert.assertTrue(interfaceOperation.isRight());
 247
 248     }
 249
 250     @Test()
 251     public void shouldFailWhenCreateInterfaceOperationFailedTest() {
 252         Resource resource = createResourceForInterfaceOperation();
 253         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 254         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 255         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 256         operation = InterfaceOperationTestUtils.createMockOperation();
 257
 258         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 259        Assert.assertTrue(bl.createInterfaceOperation(resourceId, operation, user, true).isRight());
 260     }
 261
 262     @Test
 263     public void updateInterfaceOperationTest() {
 264         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 265         operation = InterfaceOperationTestUtils.createMockOperation();
 266         Resource resource = createResourceForInterfaceOperation();
 267         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 268         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 269         when(interfaceOperation.updateInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 270
 271         Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
 272         Assert.assertTrue(interfaceOperation.isLeft());
 273     }
 274
 275     @Test()
 276     public void shouldFailWhenFailedToUpdateInterfaceOperationTest() {
 277         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 278         operation = InterfaceOperationTestUtils.createMockOperation();
 279         Resource resource = createResourceForInterfaceOperation();
 280         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 281         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 282         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 283         Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
 284         Assert.assertTrue(interfaceOperation.isRight());
 285     }
 286
 287     @Test
 288     public void deleteInterfaceOperationTest() {
 289         Resource resource = createResourceForInterfaceOperation();
 290         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 291         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 292         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 293         when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 294         when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
 295         Either<Operation, ResponseFormat> deleteResourceResponseFormatEither = bl.deleteInterfaceOperation(resourceId, operationId, user, true);
 296         Assert.assertTrue(deleteResourceResponseFormatEither.isLeft());
 297     }
 298
 299     @Test()
 300     public void shouldFailWhenDeleteInterfaceOperationFailedTest() {
 301         Resource resource = createResourceForInterfaceOperation();
 302         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 303         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 304         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 305         when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 306         when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
 307         Assert.assertTrue(bl.deleteInterfaceOperation(resourceId, operationId, user, true).isRight());
 308
 309     }
 310     @Test
 311     public void getInterfaceOperationTest() {
 312         Resource resource = createResourceForInterfaceOperation();
 313         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 314         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 315         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 316         Either<Operation, ResponseFormat> getResourceResponseFormatEither = bl.getInterfaceOperation(resourceId, operationId, user, true);
 317         Assert.assertTrue(getResourceResponseFormatEither.isLeft());
 318     }
 319
 320     @Test
 321     public void updateToscaResourceNameWhenComponentNameChanged() {
 322         Component newComponent = new Resource();
 323         newComponent.setName("newComponent");
 324         Component  oldComponent  = createResourceForInterfaceOperation();
 325         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 326         when(interfaceOperation.updateInterface(anyString(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME)));
 327         Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isLeft());
 328     }
 329
 330     @Test
 331     public void shouldFailWhenComponentNameChangedButUpdateOperationFailed() {
 332         Component newComponent = new Resource();
 333         newComponent.setName("newComponent");
 334         Component  oldComponent  = createResourceForInterfaceOperation();
 335         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 336         when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 337
 338         Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight());
 339     }
 340
 341     @Test(expected = Exception.class)
 342     public void shouldThrowExceptionWhenComponentNameChangedButUpdateOperationFailed() {
 343         Component newComponent = new Resource();
 344         newComponent.setName("newComponent");
 345         Component  oldComponent  = createResourceForInterfaceOperation();
 346         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 347         when(interfaceOperation.updateInterface(anyString(), anyObject())).thenThrow(new Exception());
 348         bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight();
 349     }
 350
 351     private void validateUserRoles(Role... roles) {
 352         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
 353     }
 354
 355     private void setCanWorkOnResource(Resource resource) {
 356         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 357         resource.setLastUpdaterUserId(user.getUserId());
 358     }
 359
 360     private Resource createResourceForInterfaceOperation() {
 361         Resource resource = new Resource();
 362         resource.setUniqueId(resourceId);
 363         resource.setName(RESOURCE_NAME);
 364         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 365         resource.setDescription("Resource name for response");
 366         resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME));
 367         return resource;
 368     }
 369
 370     private Resource createResourceObjectCsar(boolean afterCreate) {
 371         Resource resource = new Resource();
 372         resource.setName(RESOURCE_NAME);
 373         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 374         resource.setDescription("My short description");
 375         List<String> tgs = new ArrayList<>();
 376         tgs.add("test");
 377         tgs.add(resource.getName());
 378         resource.setTags(tgs);
 379         List<String> template = new ArrayList<>();
 380         template.add("Root");
 381         resource.setDerivedFrom(template);
 382         resource.setVendorName("Motorola");
 383         resource.setVendorRelease("1.0.0");
 384         resource.setResourceVendorModelNumber("");
 385         resource.setContactId("ya5467");
 386         resource.setIcon("MyIcon");
 387         resource.setCsarUUID("valid_vf.csar");
 388         resource.setCsarVersion("1");
 389
 390         if (afterCreate) {
 391             resource.setName(resource.getName());
 392             resource.setVersion("0.1");
 393             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 394             resource.setCreatorUserId(user.getUserId());
 395             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 396             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 397         }
 398         return resource;
 399     }
 400
 401     private Resource createResourceObject(boolean afterCreate) {
 402         Resource resource = new Resource();
 403         resource.setName(RESOURCE_NAME);
 404         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 405         resource.setDescription("My short description");
 406         List<String> tgs = new ArrayList<>();
 407         tgs.add("test");
 408         tgs.add(resource.getName());
 409         resource.setTags(tgs);
 410         List<String> template = new ArrayList<>();
 411         template.add("Root");
 412         resource.setDerivedFrom(template);
 413         resource.setVendorName("Motorola");
 414         resource.setVendorRelease("1.0.0");
 415         resource.setContactId("ya5467");
 416         resource.setIcon("MyIcon");
 417
 418         if (afterCreate) {
 419             resource.setName(resource.getName());
 420             resource.setVersion("0.1");
 421             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 422             resource.setCreatorUserId(user.getUserId());
 423             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 424             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 425         }
 426         return resource;
 427     }
 428
 429     @Test
 430     public void testGetAllInterfaceLifecycleTypes_TypesNotFound() {
 431         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 432         Either<Map<String, InterfaceDefinition>, ResponseFormat> response = bl.getAllInterfaceLifecycleTypes();
 433         Assert.assertTrue(response.isRight());
 434     }
 435
 436     @Test
 437     public void testGetAllInterfaceLifecycleTypes_Success() {
 438         final String UNIQUE_ID = "UNIQUE_ID";
 439         final String TYPE = "UNIQUE_ID";
 440         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 441         interfaceDefinition.setUniqueId(UNIQUE_ID);
 442         interfaceDefinition.setType(TYPE);
 443         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
 444         interfaceDefinitionMap.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
 445         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceDefinitionMap));
 446         Either<Map<String, InterfaceDefinition>, ResponseFormat>  response = bl.getAllInterfaceLifecycleTypes();
 447         Assert.assertEquals(response.left().value().size(),1);
 448     }
 449 }