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 org.assertj.core.api.Assertions.assertThat;
23 import static org.junit.jupiter.api.Assertions.assertThrows;
24 import static org.junit.jupiter.api.Assertions.fail;
25 import static org.mockito.ArgumentMatchers.any;
26 import static org.mockito.ArgumentMatchers.anyInt;
27 import static org.mockito.ArgumentMatchers.anyList;
28 import static org.mockito.ArgumentMatchers.anyString;
29 import static org.mockito.Mockito.times;
30 import static org.mockito.Mockito.verify;
31 import static org.mockito.Mockito.when;
33 import fj.data.Either;
34 import java.util.Arrays;
35 import java.util.Collections;
36 import java.util.LinkedList;
37 import java.util.List;
38 import java.util.Optional;
39 import org.junit.jupiter.api.BeforeEach;
40 import org.junit.jupiter.api.Test;
41 import org.junit.jupiter.api.extension.ExtendWith;
42 import org.mockito.InjectMocks;
43 import org.mockito.Mock;
44 import org.mockito.MockitoAnnotations;
45 import org.mockito.junit.jupiter.MockitoExtension;
46 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
47 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
48 import org.openecomp.sdc.be.components.validation.UserValidations;
49 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
50 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
51 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
52 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
53 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
54 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition;
55 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
56 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
57 import org.openecomp.sdc.be.impl.ComponentsUtils;
58 import org.openecomp.sdc.be.model.Component;
59 import org.openecomp.sdc.be.model.PropertyDefinition;
60 import org.openecomp.sdc.be.model.Service;
61 import org.openecomp.sdc.be.model.dto.FilterConstraintDto;
62 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.SubstitutionFilterOperation;
63 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
64 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
65 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
66 import org.openecomp.sdc.be.ui.mapper.FilterConstraintMapper;
67 import org.openecomp.sdc.be.ui.model.UIConstraint;
69 @ExtendWith(MockitoExtension.class)
70 class ComponentSubstitutionFilterBusinessLogicTest extends BaseBusinessLogicMock {
72 private static final String servicePropertyName = "controller_actor";
73 private static final String constraintOperator = "equal";
74 private static final String sourceType = "static";
75 private static final String sourceName = sourceType;
76 private static final String propertyValue = "constraintValue";
77 private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
80 private ComponentSubstitutionFilterBusinessLogic componentSubstitutionFilterBusinessLogic;
82 private SubstitutionFilterOperation substitutionFilterOperation;
84 private ToscaOperationFacade toscaOperationFacade;
86 private GraphLockOperation graphLockOperation;
88 private JanusGraphDao janusGraphDao;
90 private JanusGraphGenericDao janusGraphGenericDao;
92 private ComponentsUtils componentsUtils;
94 private UserValidations userValidations;
96 private NodeFilterValidator nodeFilterValidator;
98 private Component component;
99 private SubstitutionFilterDataDefinition substitutionFilterDataDefinition;
100 private SubstitutionFilterPropertyDataDefinition substitutionFilterPropertyDataDefinition;
101 private String constraint;
102 private FilterConstraintDto filterConstraintDto;
106 MockitoAnnotations.openMocks(this);
107 componentSubstitutionFilterBusinessLogic =
108 new ComponentSubstitutionFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
109 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
110 substitutionFilterOperation, nodeFilterValidator);
111 componentSubstitutionFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
112 componentSubstitutionFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
113 componentSubstitutionFilterBusinessLogic.setComponentsUtils(componentsUtils);
114 componentSubstitutionFilterBusinessLogic.setUserValidations(userValidations);
115 componentSubstitutionFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
116 componentSubstitutionFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
122 void doNotCreateSubstitutionFilterAsExistsTest() throws BusinessLogicException {
123 component.setSubstitutionFilter(substitutionFilterDataDefinition);
125 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
127 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
128 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE);
129 assertThat(result).isPresent();
130 assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
131 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
135 void createSubstitutionFilterIfNotExistTest() throws BusinessLogicException {
136 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
137 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
138 .thenReturn(StorageOperationStatus.OK);
139 when(substitutionFilterOperation.createSubstitutionFilter(componentId))
140 .thenReturn(Either.left(substitutionFilterDataDefinition));
141 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
142 .thenReturn(StorageOperationStatus.OK);
144 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
145 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE);
146 assertThat(result).isPresent();
147 assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
148 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
149 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
150 verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId);
151 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
155 void createSubstitutionFilterIfNotExistFailTest() {
156 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
157 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
158 .thenReturn(StorageOperationStatus.OK);
159 when(substitutionFilterOperation.createSubstitutionFilter(componentId))
160 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
161 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
162 .thenReturn(StorageOperationStatus.OK);
164 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
165 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE));
167 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
168 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
169 verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId);
170 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
174 void addSubstitutionFilterTest() throws BusinessLogicException {
175 component.setSubstitutionFilter(substitutionFilterDataDefinition);
177 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
178 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
179 .thenReturn(StorageOperationStatus.OK);
180 when(nodeFilterValidator.validateSubstitutionFilter(component, filterConstraintDto)).thenReturn(Either.left(true));
181 when(substitutionFilterOperation
182 .addPropertyFilter(anyString(), any(SubstitutionFilterDataDefinition.class),
183 any(SubstitutionFilterPropertyDataDefinition.class)))
184 .thenReturn(Either.left(substitutionFilterDataDefinition));
185 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
186 .thenReturn(StorageOperationStatus.OK);
188 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
189 .addSubstitutionFilter(componentId, filterConstraintDto, true, ComponentTypeEnum.SERVICE);
191 assertThat(result).isPresent();
192 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
193 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
194 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
195 verify(nodeFilterValidator, times(1)).validateSubstitutionFilter(component, filterConstraintDto);
196 verify(substitutionFilterOperation, times(1))
197 .addPropertyFilter(anyString(), any(SubstitutionFilterDataDefinition.class),
198 any(SubstitutionFilterPropertyDataDefinition.class));
199 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
204 void addSubstitutionFilterFailTest() {
205 component.setSubstitutionFilter(substitutionFilterDataDefinition);
207 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
208 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
209 .thenReturn(StorageOperationStatus.OK);
210 when(nodeFilterValidator.validateSubstitutionFilter(component, filterConstraintDto)).thenReturn(Either.left(true));
211 when(substitutionFilterOperation
212 .addPropertyFilter(componentId, substitutionFilterDataDefinition,
213 substitutionFilterPropertyDataDefinition))
214 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
216 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
217 .thenReturn(StorageOperationStatus.OK);
219 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
220 .addSubstitutionFilter(componentId, filterConstraintDto, true, ComponentTypeEnum.SERVICE));
222 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
223 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
224 verify(nodeFilterValidator, times(1)).validateSubstitutionFilter(component, filterConstraintDto);
225 verify(substitutionFilterOperation, times(0))
226 .addPropertyFilter(componentId, substitutionFilterDataDefinition,
227 substitutionFilterPropertyDataDefinition);
228 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
232 void updateSubstitutionFilterTest() throws BusinessLogicException {
233 component.setSubstitutionFilter(substitutionFilterDataDefinition);
235 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
236 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
237 .thenReturn(StorageOperationStatus.OK);
238 when(nodeFilterValidator.validateSubstitutionFilter(component, List.of(filterConstraintDto))).thenReturn(Either.left(true));
239 when(substitutionFilterOperation.updatePropertyFilters(anyString(), any(SubstitutionFilterDataDefinition.class), anyList()))
240 .thenReturn(Either.left(substitutionFilterDataDefinition));
241 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
242 .thenReturn(StorageOperationStatus.OK);
244 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
245 .updateSubstitutionFilter(componentId, List.of(filterConstraintDto), true, ComponentTypeEnum.SERVICE);
247 assertThat(result).isPresent();
248 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
249 verify(substitutionFilterOperation, times(1))
250 .updatePropertyFilters(anyString(), any(SubstitutionFilterDataDefinition.class), anyList());
251 verify(nodeFilterValidator, times(1)).validateSubstitutionFilter(component, List.of(filterConstraintDto));
252 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
253 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
254 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
258 void updateSubstitutionFilterFailTest() {
259 component.setSubstitutionFilter(substitutionFilterDataDefinition);
261 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
262 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
263 .thenReturn(StorageOperationStatus.OK);
264 when(nodeFilterValidator.validateSubstitutionFilter(component, List.of(filterConstraintDto))).thenReturn(Either.left(true));
265 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
266 .thenReturn(StorageOperationStatus.OK);
268 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
269 .updateSubstitutionFilter(componentId, List.of(filterConstraintDto), true, ComponentTypeEnum.SERVICE));
271 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
272 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
273 verify(nodeFilterValidator, times(1)).validateSubstitutionFilter(component, List.of(filterConstraintDto));
274 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
278 void deleteSubstitutionFilterTest() throws BusinessLogicException {
279 substitutionFilterDataDefinition.setProperties(new ListDataDefinition<>());
280 component.setSubstitutionFilter(substitutionFilterDataDefinition);
282 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
283 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
284 .thenReturn(StorageOperationStatus.OK);
285 when(substitutionFilterOperation.deleteConstraint(anyString(), any(SubstitutionFilterDataDefinition.class), anyInt()))
286 .thenReturn(Either.left(substitutionFilterDataDefinition));
287 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
288 .thenReturn(StorageOperationStatus.OK);
290 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
291 .deleteSubstitutionFilter(componentId, anyInt(), true, ComponentTypeEnum.SERVICE);
293 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
294 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
295 verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId,
296 substitutionFilterDataDefinition, 0);
297 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
301 void deleteSubstitutionFilterFailTest() {
302 component.setSubstitutionFilter(substitutionFilterDataDefinition);
304 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
305 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
306 .thenReturn(StorageOperationStatus.OK);
307 when(substitutionFilterOperation.deleteConstraint(anyString(),
308 any(SubstitutionFilterDataDefinition.class), anyInt()))
309 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
310 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
311 .thenReturn(StorageOperationStatus.OK);
313 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
314 .deleteSubstitutionFilter(componentId, anyInt(),true, ComponentTypeEnum.SERVICE));
316 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
317 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
318 verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId,
319 substitutionFilterDataDefinition, 0);
320 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
323 public void initResource() {
325 component = new Service();
326 component.setName("MyTestService");
327 component.setUniqueId(componentId);
329 final UIConstraint uiConstraint =
330 new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
331 final FilterConstraintMapper filterConstraintMapper = new FilterConstraintMapper();
332 filterConstraintDto = filterConstraintMapper.mapFrom(uiConstraint);
333 constraint = new ConstraintConvertor().convert(uiConstraint);
335 substitutionFilterPropertyDataDefinition = new SubstitutionFilterPropertyDataDefinition();
336 substitutionFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
337 substitutionFilterPropertyDataDefinition
338 .setConstraints(List.of(filterConstraintMapper.mapTo(filterConstraintDto)));
340 final ListDataDefinition<SubstitutionFilterPropertyDataDefinition> listDataDefinition =
341 new ListDataDefinition<>(
342 Collections.singletonList(substitutionFilterPropertyDataDefinition));
344 substitutionFilterDataDefinition = new SubstitutionFilterDataDefinition();
345 substitutionFilterDataDefinition.setProperties(listDataDefinition);
346 substitutionFilterDataDefinition.setID("SUBSTITUTION_FILTER_UID");
348 final PropertyDefinition property = new PropertyDefinition();
349 property.setName(uiConstraint.getServicePropertyName());
351 component.setProperties(new LinkedList<>(Arrays.asList(property)));
352 } catch (final Exception e) {
353 fail(e.getMessage());