gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  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  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.openecomp.sdc.be.components.impl;
  21
  22 import static java.util.Collections.singletonList;
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.jupiter.api.Assertions.assertNotNull;
  25 import static org.junit.jupiter.api.Assertions.assertThrows;
  26 import static org.junit.jupiter.api.Assertions.assertTrue;
  27 import static org.junit.jupiter.api.Assertions.fail;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31
  32 import fj.data.Either;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.Collections;
  36 import java.util.HashMap;
  37 import java.util.LinkedList;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Optional;
  41 import org.junit.jupiter.api.BeforeEach;
  42 import org.junit.jupiter.api.Test;
  43 import org.junit.jupiter.api.extension.ExtendWith;
  44 import org.mockito.InjectMocks;
  45 import org.mockito.Mock;
  46 import org.mockito.Mockito;
  47 import org.mockito.MockitoAnnotations;
  48 import org.mockito.junit.jupiter.MockitoExtension;
  49 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  50 import org.openecomp.sdc.be.components.impl.utils.DirectivesEnum;
  51 import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
  52 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  53 import org.openecomp.sdc.be.components.validation.UserValidations;
  54 import org.openecomp.sdc.be.dao.api.ActionStatus;
  55 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  56 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  57 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
  58 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  59 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  60 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
  61 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  62 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  63 import org.openecomp.sdc.be.impl.ComponentsUtils;
  64 import org.openecomp.sdc.be.model.ComponentInstance;
  65 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  66 import org.openecomp.sdc.be.model.PropertyDefinition;
  67 import org.openecomp.sdc.be.model.Resource;
  68 import org.openecomp.sdc.be.model.User;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
  70 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  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.ui.model.UIConstraint;
  74 import org.openecomp.sdc.be.user.Role;
  75
  76 @ExtendWith(MockitoExtension.class)
  77 public class ComponentNodeFilterBusinessLogicTest extends BaseBusinessLogicMock {
  78
  79     private static final String servicePropertyName = "resourceType";
  80     private static final String constraintOperator = "equal";
  81     private static final String sourceType = "static";
  82     private static final String sourceName = sourceType;
  83     private static final String propertyValue = "resourceTypeValue";
  84     private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
  85     private static final String componentInstanceId = "dac65869-dfb4-40d2-aa20-084324659ec1.resource0";
  86
  87     @InjectMocks
  88     private ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic;
  89     @Mock
  90     private NodeFilterValidator nodeFilterValidator;
  91     @Mock
  92     private NodeFilterOperation nodeFilterOperation;
  93     @Mock
  94     private ToscaOperationFacade toscaOperationFacade;
  95     @Mock
  96     private GraphLockOperation graphLockOperation;
  97     @Mock
  98     private JanusGraphDao janusGraphDao;
  99     @Mock
 100     private JanusGraphGenericDao janusGraphGenericDao;
 101     @Mock
 102     private ComponentsUtils componentsUtils;
 103     @Mock
 104     private UserValidations userValidations;
 105
 106     private Resource resource;
 107     private ComponentInstance componentInstance;
 108     private CINodeFilterDataDefinition ciNodeFilterDataDefinition;
 109     private RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition;
 110     private String constraint;
 111
 112     @BeforeEach
 113     public void init() {
 114         MockitoAnnotations.initMocks(this);
 115         componentNodeFilterBusinessLogic =
 116             new ComponentNodeFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 117                 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
 118                 nodeFilterOperation, nodeFilterValidator);
 119         componentNodeFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 120         componentNodeFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
 121         componentNodeFilterBusinessLogic.setComponentsUtils(componentsUtils);
 122         componentNodeFilterBusinessLogic.setUserValidations(userValidations);
 123         componentNodeFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
 124         componentNodeFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
 125
 126         initResource();
 127     }
 128
 129     @Test
 130     public void createWhenNodeFilterExistsTest() throws BusinessLogicException {
 131         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 132
 133         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 134
 135         final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
 136             .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 137
 138         assertThat(result).isPresent();
 139         assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
 140         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 141     }
 142
 143     @Test
 144     public void createNodeFilterFailTest() {
 145         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 146         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 147             .thenReturn(StorageOperationStatus.OK);
 148         when(componentsUtils.convertFromStorageResponse(Mockito.any())).thenReturn(ActionStatus.GENERAL_ERROR);
 149         when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
 150             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 151         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 152             .thenReturn(StorageOperationStatus.OK);
 153
 154         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 155             .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
 156
 157         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 158         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 159         verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
 160         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 161     }
 162
 163     @Test
 164     public void createNodeFilterIfNotExist() throws BusinessLogicException {
 165         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 166         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 167             .thenReturn(StorageOperationStatus.OK);
 168         when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
 169             .thenReturn(Either.left(ciNodeFilterDataDefinition));
 170         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 171             .thenReturn(StorageOperationStatus.OK);
 172
 173         final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
 174             .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 175
 176         assertThat(result).isPresent();
 177         assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
 178
 179         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 180         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 181         verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
 182         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 183     }
 184
 185     @Test
 186     public void deleteNodeFilterIfExistsTest() throws BusinessLogicException {
 187         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 188         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 189             .thenReturn(Either.left(true));
 190
 191         final Optional<String> result = componentNodeFilterBusinessLogic
 192             .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 193
 194         assertThat(result).isPresent();
 195         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 196         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
 197     }
 198
 199     @Test
 200     public void deleteWhenNodeFilterExistsTest() throws BusinessLogicException {
 201         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 202
 203         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 204         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 205             .thenReturn(StorageOperationStatus.OK);
 206         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 207             .thenReturn(Either.left(true));
 208         when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
 209             .thenReturn(Either.left(componentInstanceId));
 210         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 211             .thenReturn(StorageOperationStatus.OK);
 212
 213         final Optional<String> result = componentNodeFilterBusinessLogic
 214             .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 215
 216         assertThat(result).isPresent();
 217         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 218         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 219         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
 220         verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
 221         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 222     }
 223
 224     @Test
 225     public void deleteNodeFilterIfExistsFailTest() {
 226         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 227
 228         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 229         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 230             .thenReturn(StorageOperationStatus.OK);
 231         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 232             .thenReturn(Either.left(true));
 233         when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
 234             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 235         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 236             .thenReturn(StorageOperationStatus.OK);
 237
 238         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 239             .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
 240
 241         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 242         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 243         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
 244         verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
 245         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 246     }
 247
 248     @Test
 249     public void addNodeFilterFailTest() {
 250         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 251
 252         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 253         when(nodeFilterValidator
 254             .validateNodeFilter(resource, componentInstanceId,
 255                 requirementNodeFilterPropertyDataDefinition.getConstraints(),
 256                 NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
 257         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 258             .thenReturn(Either.left(true));
 259         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 260             .thenReturn(StorageOperationStatus.OK);
 261         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 262             .thenReturn(StorageOperationStatus.OK);
 263
 264         final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
 265         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 266             .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
 267                 "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE));
 268
 269         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 270         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 271         verify(nodeFilterValidator, times(1)).validateNodeFilter(resource, componentInstanceId,
 272             constraints, NodeFilterConstraintAction.ADD);
 273         verify(nodeFilterOperation, times(0))
 274             .addNewProperty(componentId, componentInstanceId, ciNodeFilterDataDefinition,
 275                 requirementNodeFilterPropertyDataDefinition);
 276         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 277     }
 278
 279     @Test
 280     public void addNodeFilterFailFetchComponentTest() {
 281         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 282
 283         when(toscaOperationFacade.getToscaElement(componentId))
 284             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 285
 286         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 287             .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
 288                 "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE));
 289     }
 290
 291     @Test
 292     public void deleteNodeFilterTest() throws BusinessLogicException {
 293         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 294
 295         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 296         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 297             .thenReturn(Either.left(true));
 298         when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
 299             NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 300         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 301             .thenReturn(StorageOperationStatus.OK);
 302
 303         when(nodeFilterOperation
 304             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
 305             .thenReturn(Either.left(ciNodeFilterDataDefinition));
 306
 307         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 308             .thenReturn(StorageOperationStatus.OK);
 309
 310         final Optional<CINodeFilterDataDefinition> deleteNodeFilterResult = componentNodeFilterBusinessLogic
 311             .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 312                 0, true, ComponentTypeEnum.RESOURCE);
 313
 314         assertThat(deleteNodeFilterResult).isPresent();
 315
 316         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 317         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 318         verify(nodeFilterValidator, times(1))
 319             .validateComponentInstanceExist(resource, componentInstanceId);
 320         verify(nodeFilterValidator, times(1))
 321             .validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
 322                 NodeFilterConstraintAction.DELETE);
 323         verify(nodeFilterOperation, times(1))
 324             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0);
 325         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 326     }
 327
 328     @Test
 329     public void deleteNodeFilterFailTest() {
 330         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 331
 332         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 333         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 334             .thenReturn(Either.left(true));
 335         when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
 336             NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 337         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 338             .thenReturn(StorageOperationStatus.OK);
 339
 340         when(nodeFilterOperation
 341             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
 342             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 343
 344         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 345             .thenReturn(StorageOperationStatus.OK);
 346
 347         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 348             .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 349                 0, true, ComponentTypeEnum.RESOURCE));
 350
 351         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 352         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 353         verify(nodeFilterValidator, times(1))
 354             .validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
 355                 NodeFilterConstraintAction.DELETE);
 356         verify(nodeFilterValidator, times(1))
 357             .validateComponentInstanceExist(resource, componentInstanceId);
 358         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 359     }
 360
 361     @Test
 362     public void deleteNodeFilterFailValidationTest() {
 363         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 364         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 365             .thenReturn(Either.left(true));
 366         when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
 367             NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 368
 369         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 370             .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 371                 0, true, ComponentTypeEnum.RESOURCE));
 372
 373         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 374         verify(nodeFilterValidator, times(1))
 375             .validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
 376                 NodeFilterConstraintAction.DELETE);
 377         verify(nodeFilterValidator, times(1))
 378             .validateComponentInstanceExist(resource, componentInstanceId);
 379     }
 380
 381     @Test
 382     public void updateNodeFilterFailTest() {
 383         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 384
 385         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 386         when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId,
 387             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 388         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 389             .thenReturn(StorageOperationStatus.OK);
 390         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 391             .thenReturn(StorageOperationStatus.OK);
 392
 393         final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
 394         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 395             .updateNodeFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.RESOURCE));
 396
 397         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 398         verify(nodeFilterValidator, times(1)).validateNodeFilter(resource, componentInstanceId,
 399             constraints, NodeFilterConstraintAction.UPDATE);
 400     }
 401
 402     @Test
 403     public void updateNodeFilterFailValidationTest() {
 404         final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
 405         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 406         when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId,
 407             constraints, NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 408
 409         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 410             .updateNodeFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.RESOURCE));
 411
 412         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 413         verify(nodeFilterValidator, times(1)).validateNodeFilter(resource, componentInstanceId,
 414             constraints, NodeFilterConstraintAction.UPDATE);
 415     }
 416
 417     @Test
 418     public void validateUserTes() {
 419         final String USER_ID = "jh0003";
 420         final User user = new User();
 421         user.setUserId(USER_ID);
 422         user.setRole(Role.ADMIN.name());
 423         when(userValidations.validateUserExists(USER_ID)).thenReturn(user).thenReturn(user);
 424         final User result = componentNodeFilterBusinessLogic.validateUser(USER_ID);
 425         assertNotNull(result);
 426         assertTrue(USER_ID.equalsIgnoreCase(result.getUserId()));
 427         assertTrue(Role.ADMIN.name().equalsIgnoreCase(result.getRole()));
 428     }
 429
 430     public void initResource() {
 431         try {
 432             resource = new Resource();
 433             resource.setName("MyResource");
 434             resource.setUniqueId(componentId);
 435             resource.setToscaResourceName("My_Resource_Tosca_Name");
 436             resource.addCategory("Network Layer 2-3", "Router");
 437             resource.setDescription("My short description");
 438
 439             componentInstance = new ComponentInstance();
 440             componentInstance.setUniqueId(componentInstanceId);
 441             componentInstance.setName("myComponentInstance");
 442             componentInstance.setDirectives(new LinkedList<>(Arrays.asList(DirectivesEnum.SELECT.getValue())));
 443
 444             final UIConstraint uiConstraint =
 445                 new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
 446             constraint = new ConstraintConvertor().convert(uiConstraint);
 447
 448             requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
 449             requirementNodeFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
 450             requirementNodeFilterPropertyDataDefinition.setConstraints(new LinkedList<>(Arrays.asList(constraint)));
 451
 452             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> listDataDefinition =
 453                 new ListDataDefinition<>(new LinkedList<>(Arrays.asList(requirementNodeFilterPropertyDataDefinition)));
 454
 455             ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
 456             ciNodeFilterDataDefinition.setProperties(listDataDefinition);
 457             ciNodeFilterDataDefinition.setID("NODE_FILTER_UID");
 458
 459             resource.setComponentInstances(singletonList(componentInstance));
 460
 461             final PropertyDefinition property = new PropertyDefinition();
 462             property.setName(uiConstraint.getServicePropertyName());
 463
 464             final List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 465             final ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 466             origProperty.setName(uiConstraint.getServicePropertyName());
 467             origProperty.setValue(propertyValue);
 468             origProperty.setType(uiConstraint.getSourceType());
 469             origProperties.add(origProperty);
 470
 471             final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 472             componentInstanceProps.put(componentInstanceId, origProperties);
 473
 474             resource.setComponentInstancesProperties(componentInstanceProps);
 475             resource.setProperties(new LinkedList<>(Arrays.asList(property)));
 476         } catch (final Exception e) {
 477             fail(e.getMessage());
 478         }
 479     }
 480 }