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;
40 import org.junit.jupiter.api.BeforeEach;
41 import org.junit.jupiter.api.Test;
42 import org.junit.jupiter.api.extension.ExtendWith;
43 import org.mockito.InjectMocks;
44 import org.mockito.Mock;
45 import org.mockito.MockitoAnnotations;
46 import org.mockito.junit.jupiter.MockitoExtension;
47 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
48 import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
49 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
50 import org.openecomp.sdc.be.components.validation.UserValidations;
51 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
52 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
53 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
54 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
55 import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
56 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
57 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
58 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
59 import org.openecomp.sdc.be.impl.ComponentsUtils;
60 import org.openecomp.sdc.be.model.Component;
61 import org.openecomp.sdc.be.model.Service;
62 import org.openecomp.sdc.be.model.PropertyDefinition;
63 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.SubstitutionFilterOperation;
64 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
65 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
66 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
67 import org.openecomp.sdc.be.ui.model.UIConstraint;
69 @ExtendWith(MockitoExtension.class)
70 public 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 RequirementSubstitutionFilterPropertyDataDefinition requirementSubstitutionFilterPropertyDataDefinition;
101 private String constraint;
105 MockitoAnnotations.openMocks(this);
106 componentSubstitutionFilterBusinessLogic =
107 new ComponentSubstitutionFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
108 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
109 substitutionFilterOperation, nodeFilterValidator);
110 componentSubstitutionFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
111 componentSubstitutionFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
112 componentSubstitutionFilterBusinessLogic.setComponentsUtils(componentsUtils);
113 componentSubstitutionFilterBusinessLogic.setUserValidations(userValidations);
114 componentSubstitutionFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
115 componentSubstitutionFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
121 public void doNotCreateSubstitutionFilterAsExistsTest() throws BusinessLogicException {
122 component.setSubstitutionFilter(substitutionFilterDataDefinition);
124 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
126 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
127 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE);
128 assertThat(result).isPresent();
129 assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
130 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
134 public void createSubstitutionFilterIfNotExistTest() throws BusinessLogicException {
135 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
136 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
137 .thenReturn(StorageOperationStatus.OK);
138 when(substitutionFilterOperation.createSubstitutionFilter(componentId))
139 .thenReturn(Either.left(substitutionFilterDataDefinition));
140 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
141 .thenReturn(StorageOperationStatus.OK);
143 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
144 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE);
145 assertThat(result).isPresent();
146 assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
147 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
148 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
149 verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId);
150 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
154 public void createSubstitutionFilterIfNotExistFailTest() {
155 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
156 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
157 .thenReturn(StorageOperationStatus.OK);
158 when(substitutionFilterOperation.createSubstitutionFilter(componentId))
159 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
160 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
161 .thenReturn(StorageOperationStatus.OK);
163 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
164 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE));
166 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
167 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
168 verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId);
169 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
173 public void addSubstitutionFilterTest() throws BusinessLogicException {
174 component.setSubstitutionFilter(substitutionFilterDataDefinition);
176 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
177 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
178 .thenReturn(StorageOperationStatus.OK);
179 when(nodeFilterValidator.validateComponentFilter(component, Collections.singletonList(constraint),
180 NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
181 when(substitutionFilterOperation
182 .addPropertyFilter(anyString(), any(SubstitutionFilterDataDefinition.class),
183 any(RequirementSubstitutionFilterPropertyDataDefinition.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, servicePropertyName, constraint, true,
190 ComponentTypeEnum.SERVICE);
192 assertThat(result).isPresent();
193 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
194 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
195 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
196 verify(nodeFilterValidator, times(1)).validateComponentFilter(component,
197 Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
198 verify(substitutionFilterOperation, times(1))
199 .addPropertyFilter(anyString(), any(SubstitutionFilterDataDefinition.class),
200 any(RequirementSubstitutionFilterPropertyDataDefinition.class));
201 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
206 public void addSubstitutionFilterFailTest() {
207 component.setSubstitutionFilter(substitutionFilterDataDefinition);
209 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
210 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
211 .thenReturn(StorageOperationStatus.OK);
212 when(nodeFilterValidator.validateComponentFilter(component, Collections.singletonList(constraint),
213 NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
214 when(substitutionFilterOperation
215 .addPropertyFilter(componentId, substitutionFilterDataDefinition,
216 requirementSubstitutionFilterPropertyDataDefinition))
217 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
219 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
220 .thenReturn(StorageOperationStatus.OK);
222 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
223 .addSubstitutionFilter(componentId, servicePropertyName, constraint, true,
224 ComponentTypeEnum.SERVICE));
226 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
227 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
228 verify(nodeFilterValidator, times(1)).validateComponentFilter(component,
229 Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
230 verify(substitutionFilterOperation, times(0))
231 .addPropertyFilter(componentId, substitutionFilterDataDefinition,
232 requirementSubstitutionFilterPropertyDataDefinition);
233 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
237 public void updateSubstitutionFilterTest() throws BusinessLogicException {
238 component.setSubstitutionFilter(substitutionFilterDataDefinition);
239 final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
241 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
242 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
243 .thenReturn(StorageOperationStatus.OK);
244 when(nodeFilterValidator.validateComponentFilter(component, Collections.singletonList(constraint),
245 NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
246 when(substitutionFilterOperation.updateProperties(anyString(), any(SubstitutionFilterDataDefinition.class), anyList()))
247 .thenReturn(Either.left(substitutionFilterDataDefinition));
248 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
249 .thenReturn(StorageOperationStatus.OK);
251 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
252 .updateSubstitutionFilter(componentId, Collections.singletonList(constraint),
253 true, ComponentTypeEnum.SERVICE);
255 assertThat(result).isPresent();
256 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
257 verify(substitutionFilterOperation, times(1))
258 .updateProperties(anyString(), any(SubstitutionFilterDataDefinition.class), anyList());
259 verify(nodeFilterValidator, times(1)).validateComponentFilter(component,
260 Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
261 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
262 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
263 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
267 public void updateSubstitutionFilterFailTest() {
268 component.setSubstitutionFilter(substitutionFilterDataDefinition);
270 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
271 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
272 .thenReturn(StorageOperationStatus.OK);
273 when(nodeFilterValidator.validateComponentFilter(component, Collections.singletonList(constraint),
274 NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
275 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
276 .thenReturn(StorageOperationStatus.OK);
278 final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
279 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
280 .updateSubstitutionFilter(componentId, constraints, true, ComponentTypeEnum.SERVICE));
282 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
283 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
284 verify(nodeFilterValidator, times(1)).validateComponentFilter(component,
285 Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
286 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
290 public void deleteSubstitutionFilterTest() throws BusinessLogicException {
291 substitutionFilterDataDefinition.setProperties(new ListDataDefinition<>());
292 component.setSubstitutionFilter(substitutionFilterDataDefinition);
294 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
295 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
296 .thenReturn(StorageOperationStatus.OK);
297 when(substitutionFilterOperation.deleteConstraint(anyString(), any(SubstitutionFilterDataDefinition.class), anyInt()))
298 .thenReturn(Either.left(substitutionFilterDataDefinition));
299 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
300 .thenReturn(StorageOperationStatus.OK);
302 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
303 .deleteSubstitutionFilter(componentId, anyInt(), true, ComponentTypeEnum.SERVICE);
305 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
306 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
307 verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId,
308 substitutionFilterDataDefinition, 0);
309 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
313 public void deleteSubstitutionFilterFailTest() {
314 component.setSubstitutionFilter(substitutionFilterDataDefinition);
316 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
317 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
318 .thenReturn(StorageOperationStatus.OK);
319 when(substitutionFilterOperation.deleteConstraint(anyString(),
320 any(SubstitutionFilterDataDefinition.class), anyInt()))
321 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
322 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
323 .thenReturn(StorageOperationStatus.OK);
325 final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
326 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
327 .deleteSubstitutionFilter(componentId, anyInt(),true, ComponentTypeEnum.SERVICE));
329 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
330 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
331 verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId,
332 substitutionFilterDataDefinition, 0);
333 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
336 public void initResource() {
338 component = new Service();
339 component.setName("MyTestService");
340 component.setUniqueId(componentId);
342 final UIConstraint uiConstraint =
343 new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
344 constraint = new ConstraintConvertor().convert(uiConstraint);
346 requirementSubstitutionFilterPropertyDataDefinition = new RequirementSubstitutionFilterPropertyDataDefinition();
347 requirementSubstitutionFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
348 requirementSubstitutionFilterPropertyDataDefinition
349 .setConstraints(Collections.singletonList(constraint));
351 final ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> listDataDefinition =
352 new ListDataDefinition<>(
353 Collections.singletonList(requirementSubstitutionFilterPropertyDataDefinition));
355 substitutionFilterDataDefinition = new SubstitutionFilterDataDefinition();
356 substitutionFilterDataDefinition.setProperties(listDataDefinition);
357 substitutionFilterDataDefinition.setID("SUBSTITUTION_FILTER_UID");
359 final PropertyDefinition property = new PropertyDefinition();
360 property.setName(uiConstraint.getServicePropertyName());
362 component.setProperties(new LinkedList<>(Arrays.asList(property)));
363 } catch (final Exception e) {
364 fail(e.getMessage());