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
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.
16 * SPDX-License-Identifier: Apache-2.0
17 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.components.impl;
22 import static java.util.Collections.singletonList;
23 import static org.assertj.core.api.Assertions.assertThat;
24 import static org.junit.jupiter.api.Assertions.assertEquals;
25 import static org.junit.jupiter.api.Assertions.assertNotNull;
26 import static org.junit.jupiter.api.Assertions.assertThrows;
27 import static org.junit.jupiter.api.Assertions.assertTrue;
28 import static org.junit.jupiter.api.Assertions.fail;
29 import static org.mockito.ArgumentMatchers.any;
30 import static org.mockito.ArgumentMatchers.anyList;
31 import static org.mockito.ArgumentMatchers.anyString;
32 import static org.mockito.Mockito.times;
33 import static org.mockito.Mockito.verify;
34 import static org.mockito.Mockito.when;
36 import fj.data.Either;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.Collections;
40 import java.util.HashMap;
41 import java.util.LinkedList;
42 import java.util.List;
44 import java.util.Optional;
45 import org.junit.jupiter.api.Assertions;
46 import org.junit.jupiter.api.BeforeEach;
47 import org.junit.jupiter.api.Test;
48 import org.junit.jupiter.api.extension.ExtendWith;
49 import org.mockito.ArgumentMatchers;
50 import org.mockito.InjectMocks;
51 import org.mockito.Mock;
52 import org.mockito.MockitoAnnotations;
53 import org.mockito.junit.jupiter.MockitoExtension;
54 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
55 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
56 import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
57 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
58 import org.openecomp.sdc.be.components.validation.UserValidations;
59 import org.openecomp.sdc.be.config.ConfigurationManager;
60 import org.openecomp.sdc.be.dao.api.ActionStatus;
61 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
62 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
63 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
64 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
65 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
68 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
69 import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
70 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
71 import org.openecomp.sdc.be.impl.ComponentsUtils;
72 import org.openecomp.sdc.be.model.Component;
73 import org.openecomp.sdc.be.model.ComponentInstance;
74 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
75 import org.openecomp.sdc.be.model.PropertyDefinition;
76 import org.openecomp.sdc.be.model.Resource;
77 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
78 import org.openecomp.sdc.be.model.UploadNodeFilterPropertyInfo;
79 import org.openecomp.sdc.be.model.User;
80 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
81 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
82 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
83 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
84 import org.openecomp.sdc.be.ui.model.UIConstraint;
85 import org.openecomp.sdc.be.user.Role;
87 @ExtendWith(MockitoExtension.class)
88 public class ComponentNodeFilterBusinessLogicTest extends BaseBusinessLogicMock {
90 private static final String servicePropertyName = "resourceType";
91 private static final String constraintOperator = "equal";
92 private static final String sourceType = "static";
93 private static final String sourceName = sourceType;
94 private static final String propertyValue = "resourceTypeValue";
95 private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
96 private static final String componentInstanceId = "dac65869-dfb4-40d2-aa20-084324659ec1.resource0";
97 private static final String capabilityName = "MyCapabilityName";
100 private ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic;
102 private NodeFilterValidator nodeFilterValidator;
104 private NodeFilterOperation nodeFilterOperation;
106 private ToscaOperationFacade toscaOperationFacade;
108 private GraphLockOperation graphLockOperation;
110 private JanusGraphDao janusGraphDao;
112 private JanusGraphGenericDao janusGraphGenericDao;
114 private ComponentsUtils componentsUtils;
116 private UserValidations userValidations;
118 private Resource resource;
119 private ComponentInstance componentInstance;
120 private CINodeFilterDataDefinition ciNodeFilterDataDefinition;
121 private RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition;
122 private String constraint;
123 private UIConstraint uiConstraint;
127 MockitoAnnotations.initMocks(this);
128 componentNodeFilterBusinessLogic =
129 new ComponentNodeFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
130 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
131 nodeFilterOperation, nodeFilterValidator);
132 componentNodeFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
133 componentNodeFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
134 componentNodeFilterBusinessLogic.setComponentsUtils(componentsUtils);
135 componentNodeFilterBusinessLogic.setUserValidations(userValidations);
136 componentNodeFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
137 componentNodeFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
143 public void createWhenNodeFilterExistsTest() throws BusinessLogicException {
144 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
146 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
148 final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
149 .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
151 assertThat(result).isPresent();
152 assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
153 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
157 public void createNodeFilterFailTest() {
158 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
159 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
160 .thenReturn(StorageOperationStatus.OK);
161 when(componentsUtils.convertFromStorageResponse(any())).thenReturn(ActionStatus.GENERAL_ERROR);
162 when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
163 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
164 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
165 .thenReturn(StorageOperationStatus.OK);
167 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
168 .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
170 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
171 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
172 verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
173 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
177 public void createNodeFilterIfNotExist() throws BusinessLogicException {
178 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
179 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
180 .thenReturn(StorageOperationStatus.OK);
181 when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
182 .thenReturn(Either.left(ciNodeFilterDataDefinition));
183 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
184 .thenReturn(StorageOperationStatus.OK);
186 final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
187 .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
189 assertThat(result).isPresent();
190 assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
192 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
193 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
194 verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
195 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
199 public void deleteNodeFilterIfExistsTest() throws BusinessLogicException {
200 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
201 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
202 .thenReturn(Either.left(true));
204 final Optional<String> result = componentNodeFilterBusinessLogic
205 .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
207 assertThat(result).isPresent();
208 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
209 verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
213 public void deleteWhenNodeFilterExistsTest() throws BusinessLogicException {
214 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
216 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
217 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
218 .thenReturn(StorageOperationStatus.OK);
219 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
220 .thenReturn(Either.left(true));
221 when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
222 .thenReturn(Either.left(componentInstanceId));
223 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
224 .thenReturn(StorageOperationStatus.OK);
226 final Optional<String> result = componentNodeFilterBusinessLogic
227 .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
229 assertThat(result).isPresent();
230 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
231 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
232 verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
233 verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
234 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
238 public void deleteNodeFilterIfExistsFailTest() {
239 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
241 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
242 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
243 .thenReturn(StorageOperationStatus.OK);
244 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
245 .thenReturn(Either.left(true));
246 when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
247 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
248 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
249 .thenReturn(StorageOperationStatus.OK);
251 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
252 .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
254 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
255 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
256 verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
257 verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
258 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
262 public void addNodeFilterPropertiesTest() throws BusinessLogicException {
263 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
265 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
266 when(nodeFilterValidator
267 .validateFilter(resource, componentInstanceId,
268 requirementNodeFilterPropertyDataDefinition.getConstraints(),
269 NodeFilterConstraintAction.ADD, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(true));
270 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
271 .thenReturn(Either.left(true));
272 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
273 .thenReturn(StorageOperationStatus.OK);
274 when(nodeFilterOperation.addNewProperty(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
275 any(RequirementNodeFilterPropertyDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
276 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
277 .thenReturn(StorageOperationStatus.OK);
279 final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
280 .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
281 "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE,
282 NodeFilterConstraintType.PROPERTIES, capabilityName);
284 assertThat(result).isPresent();
285 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
286 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
287 verify(nodeFilterValidator, times(1)).validateFilter(resource, componentInstanceId,
288 Collections.singletonList(constraint), NodeFilterConstraintAction.ADD, NodeFilterConstraintType.PROPERTIES);
289 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
290 verify(nodeFilterOperation, times(1))
291 .addNewProperty(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
292 any(RequirementNodeFilterPropertyDataDefinition.class));
293 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
297 public void addNodeFilterCapabilitiesTest() throws BusinessLogicException {
298 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
300 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
301 when(nodeFilterValidator
302 .validateFilter(resource, componentInstanceId,
303 requirementNodeFilterPropertyDataDefinition.getConstraints(),
304 NodeFilterConstraintAction.ADD, NodeFilterConstraintType.CAPABILITIES)).thenReturn(Either.left(true));
305 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
306 .thenReturn(Either.left(true));
307 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
308 .thenReturn(StorageOperationStatus.OK);
309 when(nodeFilterOperation.addNewCapabilities(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
310 any(RequirementNodeFilterCapabilityDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
311 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
312 .thenReturn(StorageOperationStatus.OK);
314 final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
315 .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
316 "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE,
317 NodeFilterConstraintType.CAPABILITIES, capabilityName);
319 assertThat(result).isPresent();
320 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
321 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
322 verify(nodeFilterValidator, times(1)).validateFilter(resource, componentInstanceId,
323 Collections.singletonList(constraint), NodeFilterConstraintAction.ADD, NodeFilterConstraintType.CAPABILITIES);
324 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
325 verify(nodeFilterOperation, times(1))
326 .addNewCapabilities(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
327 any(RequirementNodeFilterCapabilityDataDefinition.class));
328 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
332 public void addNodeFilterFailTest() {
333 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
335 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
336 when(nodeFilterValidator
337 .validateFilter(resource, componentInstanceId,
338 requirementNodeFilterPropertyDataDefinition.getConstraints(),
339 NodeFilterConstraintAction.ADD, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(true));
340 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
341 .thenReturn(Either.left(true));
342 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
343 .thenReturn(StorageOperationStatus.OK);
344 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
345 .thenReturn(StorageOperationStatus.OK);
347 final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
348 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
349 .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
350 "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE,
351 NodeFilterConstraintType.PROPERTIES, capabilityName));
353 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
354 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
355 verify(nodeFilterValidator, times(1)).validateFilter(resource, componentInstanceId,
356 constraints, NodeFilterConstraintAction.ADD, NodeFilterConstraintType.PROPERTIES);
357 verify(nodeFilterOperation, times(0))
358 .addNewProperty(componentId, componentInstanceId, ciNodeFilterDataDefinition,
359 requirementNodeFilterPropertyDataDefinition);
360 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
364 public void addNodeFilterFailFetchComponentTest() {
365 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
367 when(toscaOperationFacade.getToscaElement(componentId))
368 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
370 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
371 .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
372 "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE,
373 NodeFilterConstraintType.PROPERTIES, capabilityName));
377 public void deleteNodeFilterTest() throws BusinessLogicException {
378 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
380 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
381 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
382 .thenReturn(Either.left(true));
383 when(nodeFilterValidator.validateFilter(resource, componentInstanceId, singletonList(constraint),
384 NodeFilterConstraintAction.DELETE, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(true));
385 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
386 .thenReturn(StorageOperationStatus.OK);
388 when(nodeFilterOperation
389 .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
390 NodeFilterConstraintType.PROPERTIES))
391 .thenReturn(Either.left(ciNodeFilterDataDefinition));
393 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
394 .thenReturn(StorageOperationStatus.OK);
396 final Optional<CINodeFilterDataDefinition> deleteNodeFilterResult = componentNodeFilterBusinessLogic
397 .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
398 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES);
400 assertThat(deleteNodeFilterResult).isPresent();
402 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
403 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
404 verify(nodeFilterValidator, times(1))
405 .validateComponentInstanceExist(resource, componentInstanceId);
406 verify(nodeFilterValidator, times(1))
407 .validateFilter(resource, componentInstanceId, singletonList(constraint),
408 NodeFilterConstraintAction.DELETE, NodeFilterConstraintType.PROPERTIES);
409 verify(nodeFilterOperation, times(1))
410 .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
411 NodeFilterConstraintType.PROPERTIES);
412 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
416 public void deleteNodeFilterFailTest() {
417 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
419 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
420 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
421 .thenReturn(Either.left(true));
422 when(nodeFilterValidator.validateFilter(resource, componentInstanceId, singletonList(constraint),
423 NodeFilterConstraintAction.DELETE, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(true));
424 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
425 .thenReturn(StorageOperationStatus.OK);
427 when(nodeFilterOperation
428 .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
429 NodeFilterConstraintType.PROPERTIES))
430 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
432 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
433 .thenReturn(StorageOperationStatus.OK);
435 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
436 .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
437 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES));
439 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
440 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
441 verify(nodeFilterValidator, times(1))
442 .validateFilter(resource, componentInstanceId, singletonList(constraint),
443 NodeFilterConstraintAction.DELETE, NodeFilterConstraintType.PROPERTIES);
444 verify(nodeFilterValidator, times(1))
445 .validateComponentInstanceExist(resource, componentInstanceId);
446 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
450 public void deleteNodeFilterFailValidationTest() {
451 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
452 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
453 .thenReturn(Either.left(true));
454 when(nodeFilterValidator.validateFilter(resource, componentInstanceId, singletonList(constraint),
455 NodeFilterConstraintAction.DELETE, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(true));
457 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
458 .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
459 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES));
461 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
462 verify(nodeFilterValidator, times(1))
463 .validateFilter(resource, componentInstanceId, singletonList(constraint),
464 NodeFilterConstraintAction.DELETE, NodeFilterConstraintType.PROPERTIES);
465 verify(nodeFilterValidator, times(1))
466 .validateComponentInstanceExist(resource, componentInstanceId);
470 public void updateNodeFilterTest() throws BusinessLogicException {
471 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
473 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
474 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
475 .thenReturn(Either.left(true));
476 when(nodeFilterValidator
477 .validateFilter(ArgumentMatchers.any(Component.class), anyString(), anyList(),
478 ArgumentMatchers.any(NodeFilterConstraintAction.class),
479 ArgumentMatchers.any(NodeFilterConstraintType.class))).thenReturn(Either.left(true));
481 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
482 .thenReturn(StorageOperationStatus.OK);
484 when(nodeFilterOperation.deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition,
485 0, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(ciNodeFilterDataDefinition));
487 when(nodeFilterOperation.addNewProperty(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
488 any(RequirementNodeFilterPropertyDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
490 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
491 .thenReturn(StorageOperationStatus.OK);
493 final Optional<CINodeFilterDataDefinition> updateNodeFilterResult = componentNodeFilterBusinessLogic
494 .updateNodeFilter(componentId, componentInstanceId, uiConstraint, ComponentTypeEnum.RESOURCE,
495 NodeFilterConstraintType.PROPERTIES, 0);
497 assertThat(updateNodeFilterResult).isPresent();
498 assertThat(updateNodeFilterResult.get().getProperties().getListToscaDataDefinition()).hasSize(1);
502 public void updateNodeFilterFailTest() {
503 componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
505 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
506 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
507 .thenReturn(Either.left(true));
508 when(nodeFilterValidator
509 .validateFilter(ArgumentMatchers.any(Component.class), anyString(), anyList(),
510 ArgumentMatchers.any(NodeFilterConstraintAction.class),
511 ArgumentMatchers.any(NodeFilterConstraintType.class))).thenReturn(Either.left(true));
513 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
514 .thenReturn(StorageOperationStatus.OK);
516 when(nodeFilterOperation.deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition,
517 0, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(ciNodeFilterDataDefinition));
519 when(nodeFilterOperation.addNewProperty(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
520 any(RequirementNodeFilterPropertyDataDefinition.class))).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
522 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
523 .thenReturn(StorageOperationStatus.OK);
525 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
526 .updateNodeFilter(componentId, componentInstanceId, uiConstraint, ComponentTypeEnum.RESOURCE,
527 NodeFilterConstraintType.PROPERTIES, 0));
531 public void updateNodeFilterFailValidationTest() {
532 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
533 when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
534 .thenReturn(Either.left(true));
535 when(nodeFilterValidator
536 .validateFilter(ArgumentMatchers.any(Component.class), anyString(), anyList(),
537 ArgumentMatchers.any(NodeFilterConstraintAction.class),
538 ArgumentMatchers.any(NodeFilterConstraintType.class))).thenReturn(Either.left(true));
540 assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
541 .updateNodeFilter(componentId, componentInstanceId, uiConstraint, ComponentTypeEnum.RESOURCE,
542 NodeFilterConstraintType.PROPERTIES, 0));
544 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
548 public void testAssociateNodeFilterToComponentInstance() {
549 CINodeFilterDataDefinition ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
551 UploadNodeFilterInfo filter = new UploadNodeFilterInfo();
552 UploadNodeFilterPropertyInfo propertyDataDefinition = new UploadNodeFilterPropertyInfo();
553 propertyDataDefinition.setName("order");
554 propertyDataDefinition.setValues(Collections.singletonList("order: {equal: 2"));
555 List<UploadNodeFilterPropertyInfo> propertyList = new LinkedList<>();
556 propertyList.add(propertyDataDefinition);
557 filter.setProperties(Collections.singletonList(propertyDataDefinition));
559 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
560 nodeFilterMap.put(componentInstanceId, filter);
562 when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId)).thenReturn(Either.left(ciNodeFilterDataDefinition));
563 when(nodeFilterOperation.addNewProperty(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
564 any(RequirementNodeFilterPropertyDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
566 StorageOperationStatus status = componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(componentId, nodeFilterMap);
567 assertEquals(StorageOperationStatus.OK, status);
571 public void testAssociateNodeFilterToComponentInstanceFail() {
572 CINodeFilterDataDefinition ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
574 UploadNodeFilterInfo filter = new UploadNodeFilterInfo();
575 UploadNodeFilterPropertyInfo propertyDataDefinition = new UploadNodeFilterPropertyInfo();
576 propertyDataDefinition.setName("order");
577 propertyDataDefinition.setValues(Collections.singletonList("order: {equal: 2"));
578 List<UploadNodeFilterPropertyInfo> propertyList = new LinkedList<>();
579 propertyList.add(propertyDataDefinition);
580 filter.setProperties(Collections.singletonList(propertyDataDefinition));
582 Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
583 nodeFilterMap.put(componentInstanceId, filter);
585 when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId)).thenReturn(Either.left(ciNodeFilterDataDefinition));
586 when(nodeFilterOperation.addNewProperty(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
587 any(RequirementNodeFilterPropertyDataDefinition.class))).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
589 Assertions.assertThrows(ComponentException.class, () -> componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(componentId,
594 public void validateUserTes() {
595 final String USER_ID = "jh0003";
596 final User user = new User();
597 user.setUserId(USER_ID);
598 user.setRole(Role.ADMIN.name());
599 when(userValidations.validateUserExists(USER_ID)).thenReturn(user).thenReturn(user);
600 final User result = componentNodeFilterBusinessLogic.validateUser(USER_ID);
601 assertNotNull(result);
602 assertTrue(USER_ID.equalsIgnoreCase(result.getUserId()));
603 assertTrue(Role.ADMIN.name().equalsIgnoreCase(result.getRole()));
606 public void initResource() {
608 resource = new Resource();
609 resource.setName("MyResource");
610 resource.setUniqueId(componentId);
611 resource.setToscaResourceName("My_Resource_Tosca_Name");
612 resource.addCategory("Network Layer 2-3", "Router");
613 resource.setDescription("My short description");
615 componentInstance = new ComponentInstance();
616 componentInstance.setUniqueId(componentInstanceId);
617 componentInstance.setName("myComponentInstance");
618 componentInstance.setDirectives(ConfigurationManager.getConfigurationManager().getConfiguration()
621 uiConstraint = new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
622 constraint = new ConstraintConvertor().convert(uiConstraint);
624 requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
625 requirementNodeFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
626 requirementNodeFilterPropertyDataDefinition.setConstraints(new LinkedList<>(Arrays.asList(constraint)));
628 final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> listDataDefinition =
629 new ListDataDefinition<>(new LinkedList<>(Arrays.asList(requirementNodeFilterPropertyDataDefinition)));
631 ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
632 ciNodeFilterDataDefinition.setProperties(listDataDefinition);
633 ciNodeFilterDataDefinition.setID("NODE_FILTER_UID");
635 resource.setComponentInstances(singletonList(componentInstance));
637 final PropertyDefinition property = new PropertyDefinition();
638 property.setName(uiConstraint.getServicePropertyName());
640 final List<ComponentInstanceProperty> origProperties = new ArrayList<>();
641 final ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
642 origProperty.setName(uiConstraint.getServicePropertyName());
643 origProperty.setValue(propertyValue);
644 origProperty.setType(uiConstraint.getSourceType());
645 origProperties.add(origProperty);
647 final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
648 componentInstanceProps.put(componentInstanceId, origProperties);
650 resource.setComponentInstancesProperties(componentInstanceProps);
651 resource.setProperties(new LinkedList<>(Arrays.asList(property)));
652 } catch (final Exception e) {
653 fail(e.getMessage());