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.jsongraph.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.Service;
61 import org.openecomp.sdc.be.model.PropertyDefinition;
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.model.UIConstraint;
68 @ExtendWith(MockitoExtension.class)
69 public class ComponentSubstitutionFilterBusinessLogicTest extends BaseBusinessLogicMock {
71 private static final String servicePropertyName = "controller_actor";
72 private static final String constraintOperator = "equal";
73 private static final String sourceType = "static";
74 private static final String sourceName = sourceType;
75 private static final String propertyValue = "constraintValue";
76 private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
79 private ComponentSubstitutionFilterBusinessLogic componentSubstitutionFilterBusinessLogic;
81 private SubstitutionFilterOperation substitutionFilterOperation;
83 private ToscaOperationFacade toscaOperationFacade;
85 private GraphLockOperation graphLockOperation;
87 private JanusGraphDao janusGraphDao;
89 private JanusGraphGenericDao janusGraphGenericDao;
91 private ComponentsUtils componentsUtils;
93 private UserValidations userValidations;
95 private NodeFilterValidator nodeFilterValidator;
97 private Service service;
98 private SubstitutionFilterDataDefinition substitutionFilterDataDefinition;
99 private RequirementSubstitutionFilterPropertyDataDefinition requirementSubstitutionFilterPropertyDataDefinition;
100 private String constraint;
104 MockitoAnnotations.initMocks(this);
105 componentSubstitutionFilterBusinessLogic =
106 new ComponentSubstitutionFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
107 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
108 substitutionFilterOperation, nodeFilterValidator);
109 componentSubstitutionFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
110 componentSubstitutionFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
111 componentSubstitutionFilterBusinessLogic.setComponentsUtils(componentsUtils);
112 componentSubstitutionFilterBusinessLogic.setUserValidations(userValidations);
113 componentSubstitutionFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
114 componentSubstitutionFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
120 public void doNotCreateSubstitutionFilterAsExistsTest() throws BusinessLogicException {
121 service.setSubstitutionFilter(substitutionFilterDataDefinition);
123 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
125 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
126 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE);
127 assertThat(result).isPresent();
128 assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
129 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
133 public void createSubstitutionFilterIfNotExistTest() throws BusinessLogicException {
134 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
135 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
136 .thenReturn(StorageOperationStatus.OK);
137 when(substitutionFilterOperation.createSubstitutionFilter(componentId))
138 .thenReturn(Either.left(substitutionFilterDataDefinition));
139 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
140 .thenReturn(StorageOperationStatus.OK);
142 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
143 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE);
144 assertThat(result).isPresent();
145 assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
146 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
147 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
148 verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId);
149 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
153 public void createSubstitutionFilterIfNotExistFailTest() {
154 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
155 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
156 .thenReturn(StorageOperationStatus.OK);
157 when(substitutionFilterOperation.createSubstitutionFilter(componentId))
158 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
159 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
160 .thenReturn(StorageOperationStatus.OK);
162 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
163 .createSubstitutionFilterIfNotExist(componentId, true, ComponentTypeEnum.SERVICE));
165 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
166 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
167 verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId);
168 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
172 public void addSubstitutionFilterTest() throws BusinessLogicException {
173 service.setSubstitutionFilter(substitutionFilterDataDefinition);
175 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
176 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
177 .thenReturn(StorageOperationStatus.OK);
178 when(nodeFilterValidator.validateComponentFilter(service, Collections.singletonList(constraint),
179 NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
180 when(substitutionFilterOperation
181 .addPropertyFilter(anyString(), any(SubstitutionFilterDataDefinition.class),
182 any(RequirementSubstitutionFilterPropertyDataDefinition.class)))
183 .thenReturn(Either.left(substitutionFilterDataDefinition));
184 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
185 .thenReturn(StorageOperationStatus.OK);
187 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
188 .addSubstitutionFilter(componentId, servicePropertyName, constraint, true,
189 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)).validateComponentFilter(service,
196 Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
197 verify(substitutionFilterOperation, times(1))
198 .addPropertyFilter(anyString(), any(SubstitutionFilterDataDefinition.class),
199 any(RequirementSubstitutionFilterPropertyDataDefinition.class));
200 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
205 public void addSubstitutionFilterFailTest() {
206 service.setSubstitutionFilter(substitutionFilterDataDefinition);
208 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
209 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
210 .thenReturn(StorageOperationStatus.OK);
211 when(nodeFilterValidator.validateComponentFilter(service, Collections.singletonList(constraint),
212 NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
213 when(substitutionFilterOperation
214 .addPropertyFilter(componentId, substitutionFilterDataDefinition,
215 requirementSubstitutionFilterPropertyDataDefinition))
216 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
218 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
219 .thenReturn(StorageOperationStatus.OK);
221 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
222 .addSubstitutionFilter(componentId, servicePropertyName, constraint, true,
223 ComponentTypeEnum.SERVICE));
225 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
226 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
227 verify(nodeFilterValidator, times(1)).validateComponentFilter(service,
228 Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
229 verify(substitutionFilterOperation, times(0))
230 .addPropertyFilter(componentId, substitutionFilterDataDefinition,
231 requirementSubstitutionFilterPropertyDataDefinition);
232 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
236 public void updateSubstitutionFilterTest() throws BusinessLogicException {
237 service.setSubstitutionFilter(substitutionFilterDataDefinition);
238 final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
240 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
241 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
242 .thenReturn(StorageOperationStatus.OK);
243 when(nodeFilterValidator.validateComponentFilter(service, Collections.singletonList(constraint),
244 NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
245 when(substitutionFilterOperation.updateProperties(anyString(), any(SubstitutionFilterDataDefinition.class), anyList()))
246 .thenReturn(Either.left(substitutionFilterDataDefinition));
247 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
248 .thenReturn(StorageOperationStatus.OK);
250 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
251 .updateSubstitutionFilter(componentId, Collections.singletonList(constraint),
252 true, ComponentTypeEnum.SERVICE);
254 assertThat(result).isPresent();
255 assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
256 verify(substitutionFilterOperation, times(1))
257 .updateProperties(anyString(), any(SubstitutionFilterDataDefinition.class), anyList());
258 verify(nodeFilterValidator, times(1)).validateComponentFilter(service,
259 Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
260 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
261 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
262 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
266 public void updateSubstitutionFilterFailTest() {
267 service.setSubstitutionFilter(substitutionFilterDataDefinition);
269 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
270 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
271 .thenReturn(StorageOperationStatus.OK);
272 when(nodeFilterValidator.validateComponentFilter(service, Collections.singletonList(constraint),
273 NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
274 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
275 .thenReturn(StorageOperationStatus.OK);
277 final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
278 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
279 .updateSubstitutionFilter(componentId, constraints, true, ComponentTypeEnum.SERVICE));
281 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
282 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
283 verify(nodeFilterValidator, times(1)).validateComponentFilter(service,
284 Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
285 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
289 public void deleteSubstitutionFilterTest() throws BusinessLogicException {
290 substitutionFilterDataDefinition.setProperties(new ListDataDefinition<>());
291 service.setSubstitutionFilter(substitutionFilterDataDefinition);
293 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
294 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
295 .thenReturn(StorageOperationStatus.OK);
296 when(substitutionFilterOperation.deleteConstraint(anyString(), any(SubstitutionFilterDataDefinition.class), anyInt()))
297 .thenReturn(Either.left(substitutionFilterDataDefinition));
298 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
299 .thenReturn(StorageOperationStatus.OK);
301 final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
302 .deleteSubstitutionFilter(componentId, anyInt(), true, ComponentTypeEnum.SERVICE);
304 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
305 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
306 verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId,
307 substitutionFilterDataDefinition, 0);
308 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
312 public void deleteSubstitutionFilterFailTest() {
313 service.setSubstitutionFilter(substitutionFilterDataDefinition);
315 when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
316 when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
317 .thenReturn(StorageOperationStatus.OK);
318 when(substitutionFilterOperation.deleteConstraint(anyString(),
319 any(SubstitutionFilterDataDefinition.class), anyInt()))
320 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
321 when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
322 .thenReturn(StorageOperationStatus.OK);
324 final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
325 assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
326 .deleteSubstitutionFilter(componentId, anyInt(),true, ComponentTypeEnum.SERVICE));
328 verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
329 verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
330 verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId,
331 substitutionFilterDataDefinition, 0);
332 verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
335 public void initResource() {
337 service = new Service();
338 service.setName("MyTestService");
339 service.setUniqueId(componentId);
341 final UIConstraint uiConstraint =
342 new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
343 constraint = new ConstraintConvertor().convert(uiConstraint);
345 requirementSubstitutionFilterPropertyDataDefinition = new RequirementSubstitutionFilterPropertyDataDefinition();
346 requirementSubstitutionFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
347 requirementSubstitutionFilterPropertyDataDefinition
348 .setConstraints(Collections.singletonList(constraint));
350 final ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> listDataDefinition =
351 new ListDataDefinition<>(
352 Collections.singletonList(requirementSubstitutionFilterPropertyDataDefinition));
354 substitutionFilterDataDefinition = new SubstitutionFilterDataDefinition();
355 substitutionFilterDataDefinition.setProperties(listDataDefinition);
356 substitutionFilterDataDefinition.setID("SUBSTITUTION_FILTER_UID");
358 final PropertyDefinition property = new PropertyDefinition();
359 property.setName(uiConstraint.getServicePropertyName());
361 service.setProperties(new LinkedList<>(Arrays.asList(property)));
362 } catch (final Exception e) {
363 fail(e.getMessage());