gerrit.onap Code Review - sdc.git/blob

   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.user.Role;
  74 import org.openecomp.sdc.be.user.UserBusinessLogic;
  75 import org.openecomp.sdc.common.api.ConfigurationSource;
  76 import org.openecomp.sdc.common.api.Constants;
  77 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  78 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  79 import org.openecomp.sdc.exception.ResponseFormat;
  80 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
  81 import org.springframework.web.context.WebApplicationContext;
  82
  83 public class InterfaceOperationBusinessLogicTest {
  84
  85     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
  86     private static final String RESOURCE_SUBCATEGORY = "Router";
  87
  88     private final String resourceId = "resourceId1";
  89     private final String operationId = "uniqueId1";
  90     private Operation operation;
  91
  92     private static final String RESOURCE_NAME = "Resource1";
  93
  94     private final ServletContext servletContext = Mockito.mock(ServletContext.class);
  95     private final TitanDao mockTitanDao = Mockito.mock(TitanDao.class);
  96     private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
  97     private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
  98     private final NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class);
  99     private final NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class);
 100     private final TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
 101     private final IPropertyOperation propertyOperation = Mockito.mock(IPropertyOperation.class);
 102     private final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 103     private final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
 104     private final UserValidations userValidations = Mockito.mock(UserValidations.class);
 105     private final WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
 106     private final ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class);
 107     private final InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class);
 108     private final InterfaceOperationValidation operationValidator = Mockito.mock(InterfaceOperationValidation.class);
 109
 110     private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
 111     private User user = null;
 112     private final ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic();
 113
 114     @InjectMocks
 115     private
 116     InterfaceOperationBusinessLogic bl = new InterfaceOperationBusinessLogic();
 117
 118     @Before
 119     public void setup() {
 120         MockitoAnnotations.initMocks(this);
 121         Mockito.reset(propertyOperation);
 122
 123         ExternalConfiguration.setAppName("catalog-be");
 124
 125         // init Configuration
 126         String appConfigDir = "src/test/resources/config/catalog-be";
 127         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 128         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 129         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 130
 131         // Elements
 132         IElementOperation mockElementDao = new ElementOperationMock();
 133
 134         // User data and management
 135         user = new User();
 136         user.setUserId("jh0003");
 137         user.setFirstName("Jimmi");
 138         user.setLastName("Hendrix");
 139         user.setRole(Role.ADMIN.name());
 140
 141         Either<User, ActionStatus> eitherGetUser = Either.left(user);
 142         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
 143         when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).thenReturn(user);
 144         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 145         // Servlet Context attributes
 146         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 147         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 148         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 149         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 150
 151         Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true);
 152         when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherFalse);
 153
 154         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 155         when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
 156
 157         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 158         when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
 159
 160         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
 161         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 162
 163         Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false);
 164         when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists);
 165         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 166         when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 167
 168         // createResource
 169         Resource resourceResponse = createResourceObject(true);
 170         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 171         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 172         //TODO Remove if passes
 173         /*when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate);*/
 174         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 175         when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 176
 177         //InterfaceOperation
 178         when(operationValidator.validateInterfaceOperations(anyCollection(), anyObject(), anyBoolean())).thenReturn(Either.left(true));
 179         when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK);
 180
 181         // BL object
 182         artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
 183         bl = new InterfaceOperationBusinessLogic();
 184
 185         bl.setUserAdmin(mockUserAdmin);
 186         bl.setComponentsUtils(componentsUtils);
 187         bl.setGraphLockOperation(graphLockOperation);
 188         bl.setTitanGenericDao(mockTitanDao);
 189         toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation);
 190         toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation);
 191         bl.setToscaOperationFacade(toscaOperationFacade);
 192         bl.setUserValidations(userValidations);
 193         bl.setInterfaceOperation(interfaceOperation);
 194         bl.setInterfaceOperationValidation(operationValidator);
 195         Resource resourceCsar = createResourceObjectCsar(true);
 196         setCanWorkOnResource(resourceCsar);
 197         Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar);
 198         when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes);
 199     }
 200
 201     @Test
 202     public void createInterfaceOperationTest() {
 203         Resource resource = createResourceForInterfaceOperation();
 204         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 205         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 206         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 207         operation = InterfaceOperationTestUtils.createMockOperation();
 208         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 209
 210         Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
 211         Assert.assertTrue(interfaceOperation.isLeft());
 212         Assert.assertNotNull(interfaceOperation.left().value().getWorkflowId());
 213         Assert.assertNotNull(interfaceOperation.left().value().getWorkflowVersionId());
 214     }
 215
 216     @Test
 217     public void createInterfaceOperationWithoutInterfaceTest() {
 218         Resource resource = createResourceObjectCsar(true);
 219         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 220         resource.setInterfaces(new HashMap<>());
 221         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 222         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 223         operation = InterfaceOperationTestUtils.createMockOperation();
 224         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 225         when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.left(new InterfaceDefinition()));
 226
 227         Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
 228         Assert.assertTrue(interfaceOperation.isLeft());
 229
 230     }
 231
 232     @Test
 233     public void shouldFailCreateInterfaceOperationWhenCreateOperationFailedTest() {
 234         Resource resource = createResourceObjectCsar(true);
 235         resource.setInterfaces(new HashMap<>());
 236         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 237         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 238         operation = InterfaceOperationTestUtils.createMockOperation();
 239         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 240         when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 241
 242         Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
 243         Assert.assertTrue(interfaceOperation.isRight());
 244
 245     }
 246
 247     @Test()
 248     public void shouldFailWhenCreateInterfaceOperationFailedTest() {
 249         Resource resource = createResourceForInterfaceOperation();
 250         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 251         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 252         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 253         operation = InterfaceOperationTestUtils.createMockOperation();
 254
 255         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 256        Assert.assertTrue(bl.createInterfaceOperation(resourceId, operation, user, true).isRight());
 257     }
 258
 259     @Test
 260     public void updateInterfaceOperationTest() {
 261         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 262         operation = InterfaceOperationTestUtils.createMockOperation();
 263         Resource resource = createResourceForInterfaceOperation();
 264         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 265         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 266         when(interfaceOperation.updateInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 267
 268         Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
 269         Assert.assertTrue(interfaceOperation.isLeft());
 270     }
 271
 272     @Test()
 273     public void shouldFailWhenFailedToUpdateInterfaceOperationTest() {
 274         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 275         operation = InterfaceOperationTestUtils.createMockOperation();
 276         Resource resource = createResourceForInterfaceOperation();
 277         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 278         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 279         when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 280         Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
 281         Assert.assertTrue(interfaceOperation.isRight());
 282     }
 283
 284     @Test
 285     public void deleteInterfaceOperationTest() {
 286         Resource resource = createResourceForInterfaceOperation();
 287         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 288         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 289         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 290         when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
 291         when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
 292         Either<Operation, ResponseFormat> deleteResourceResponseFormatEither = bl.deleteInterfaceOperation(resourceId, operationId, user, true);
 293         Assert.assertTrue(deleteResourceResponseFormatEither.isLeft());
 294     }
 295
 296     @Test()
 297     public void shouldFailWhenDeleteInterfaceOperationFailedTest() {
 298         Resource resource = createResourceForInterfaceOperation();
 299         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 300         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 301         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 302         when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 303         when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
 304         Assert.assertTrue(bl.deleteInterfaceOperation(resourceId, operationId, user, true).isRight());
 305
 306     }
 307     @Test
 308     public void getInterfaceOperationTest() {
 309         Resource resource = createResourceForInterfaceOperation();
 310         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 311         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 312         when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
 313         Either<Operation, ResponseFormat> getResourceResponseFormatEither = bl.getInterfaceOperation(resourceId, operationId, user, true);
 314         Assert.assertTrue(getResourceResponseFormatEither.isLeft());
 315     }
 316
 317     @Test
 318     public void updateToscaResourceNameWhenComponentNameChanged() {
 319         Component newComponent = new Resource();
 320         newComponent.setName("newComponent");
 321         Component  oldComponent  = createResourceForInterfaceOperation();
 322         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 323         when(interfaceOperation.updateInterface(anyString(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME)));
 324         Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isLeft());
 325     }
 326
 327     @Test
 328     public void shouldFailWhenComponentNameChangedButUpdateOperationFailed() {
 329         Component newComponent = new Resource();
 330         newComponent.setName("newComponent");
 331         Component  oldComponent  = createResourceForInterfaceOperation();
 332         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 333         when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 334
 335         Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight());
 336     }
 337
 338     @Test(expected = Exception.class)
 339     public void shouldThrowExceptionWhenComponentNameChangedButUpdateOperationFailed() {
 340         Component newComponent = new Resource();
 341         newComponent.setName("newComponent");
 342         Component  oldComponent  = createResourceForInterfaceOperation();
 343         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 344         when(interfaceOperation.updateInterface(anyString(), anyObject())).thenThrow(new Exception());
 345         bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight();
 346     }
 347
 348     private void validateUserRoles(Role... roles) {
 349         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
 350     }
 351
 352     private void setCanWorkOnResource(Resource resource) {
 353         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 354         resource.setLastUpdaterUserId(user.getUserId());
 355     }
 356
 357     private Resource createResourceForInterfaceOperation() {
 358         Resource resource = new Resource();
 359         resource.setUniqueId(resourceId);
 360         resource.setName(RESOURCE_NAME);
 361         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 362         resource.setDescription("Resource name for response");
 363         resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME));
 364         return resource;
 365     }
 366
 367     private Resource createResourceObjectCsar(boolean afterCreate) {
 368         Resource resource = new Resource();
 369         resource.setName(RESOURCE_NAME);
 370         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 371         resource.setDescription("My short description");
 372         List<String> tgs = new ArrayList<>();
 373         tgs.add("test");
 374         tgs.add(resource.getName());
 375         resource.setTags(tgs);
 376         List<String> template = new ArrayList<>();
 377         template.add("Root");
 378         resource.setDerivedFrom(template);
 379         resource.setVendorName("Motorola");
 380         resource.setVendorRelease("1.0.0");
 381         resource.setResourceVendorModelNumber("");
 382         resource.setContactId("ya5467");
 383         resource.setIcon("MyIcon");
 384         resource.setCsarUUID("valid_vf.csar");
 385         resource.setCsarVersion("1");
 386
 387         if (afterCreate) {
 388             resource.setName(resource.getName());
 389             resource.setVersion("0.1");
 390             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 391             resource.setCreatorUserId(user.getUserId());
 392             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 393             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 394         }
 395         return resource;
 396     }
 397
 398     private Resource createResourceObject(boolean afterCreate) {
 399         Resource resource = new Resource();
 400         resource.setName(RESOURCE_NAME);
 401         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 402         resource.setDescription("My short description");
 403         List<String> tgs = new ArrayList<>();
 404         tgs.add("test");
 405         tgs.add(resource.getName());
 406         resource.setTags(tgs);
 407         List<String> template = new ArrayList<>();
 408         template.add("Root");
 409         resource.setDerivedFrom(template);
 410         resource.setVendorName("Motorola");
 411         resource.setVendorRelease("1.0.0");
 412         resource.setContactId("ya5467");
 413         resource.setIcon("MyIcon");
 414
 415         if (afterCreate) {
 416             resource.setName(resource.getName());
 417             resource.setVersion("0.1");
 418             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 419             resource.setCreatorUserId(user.getUserId());
 420             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 421             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 422         }
 423         return resource;
 424     }
 425
 426
 427
 428 }