catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import static org.junit.Assert.assertNotNull;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.ArgumentMatchers.eq;
  27 import static org.mockito.Mockito.verify;
  28 import static org.mockito.Mockito.when;
  29
  30 import fj.data.Either;
  31 import java.util.ArrayList;
  32 import java.util.Collections;
  33 import java.util.List;
  34 import java.util.Map;
  35 import org.apache.commons.lang3.StringUtils;
  36 import org.apache.commons.lang3.tuple.ImmutablePair;
  37 import org.junit.Assert;
  38 import org.junit.jupiter.api.BeforeAll;
  39 import org.junit.jupiter.api.BeforeEach;
  40 import org.junit.jupiter.api.Test;
  41 import org.mockito.InjectMocks;
  42 import org.mockito.Mockito;
  43 import org.mockito.MockitoAnnotations;
  44 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  45 import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
  46 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  47 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  48 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  49 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  50 import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
  52 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  53 import org.openecomp.sdc.be.model.InterfaceDefinition;
  54 import org.openecomp.sdc.be.model.ModelTestBase;
  55 import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
  56 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  57 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  58 import org.openecomp.sdc.be.resources.data.InterfaceData;
  59 import org.openecomp.sdc.be.resources.data.ModelData;
  60 import org.openecomp.sdc.be.resources.data.OperationData;
  61 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  62 import org.openecomp.sdc.be.resources.data.UserData;
  63 import org.openecomp.sdc.be.resources.data.category.CategoryData;
  64 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
  65
  66 @SpringJUnitConfig(locations = "classpath:application-context-test.xml")
  67 public class InterfaceLifecycleOperationTest {
  68
  69     private static String USER_ID = "muUserId";
  70     private static String CATEGORY_NAME = "category/mycategory";
  71     private static String MODEL_NAME = "Test";
  72     private static String INTERFACE_TYPE = "tosca.interfaces.standard";
  73
  74     JanusGraphGenericDao janusGraphGenericDao = Mockito.mock(JanusGraphGenericDao.class);
  75     ModelOperation modelOperation = Mockito.mock(ModelOperation.class);
  76     @InjectMocks
  77     private InterfaceLifecycleOperation interfaceLifecycleOperation = new InterfaceLifecycleOperation();
  78
  79     @BeforeAll
  80     public static void setupBeforeClass() {
  81         ModelTestBase.init();
  82     }
  83
  84     @BeforeEach
  85     public void createUserAndCategory() {
  86         MockitoAnnotations.openMocks(this);
  87         CategoryData categoryData = new CategoryData(NodeTypeEnum.ResourceCategory);
  88         when(janusGraphGenericDao.createNode(any(), any())).thenReturn(Either.left(categoryData));
  89         deleteAndCreateCategory(CATEGORY_NAME);
  90         deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
  91     }
  92
  93     @Test
  94     public void testDummy() {
  95         assertNotNull(interfaceLifecycleOperation);
  96     }
  97
  98     private InterfaceDefinition buildInterfaceDefinition() {
  99         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 100         interfaceDefinition.setType(INTERFACE_TYPE);
 101         interfaceDefinition.setCreationDate(101232L);
 102         interfaceDefinition.setModel(MODEL_NAME);
 103         return interfaceDefinition;
 104     }
 105
 106     private void deleteAndCreateCategory(String category) {
 107         String[] names = category.split("/");
 108         OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphGenericDao);
 109     }
 110
 111     private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
 112         UserData userData = new UserData();
 113         userData.setUserId(userId);
 114         userData.setFirstName(firstName);
 115         userData.setLastName(lastName);
 116
 117         janusGraphGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId,
 118             UserData.class);
 119         janusGraphGenericDao.createNode(userData, UserData.class);
 120         janusGraphGenericDao.commit();
 121
 122         return userData;
 123     }
 124
 125     @Test
 126     public void createInterfaceOnResourceTest() {
 127         when(janusGraphGenericDao.getChildrenNodes(any(), any(), any(), any(), eq(InterfaceData.class))).thenReturn(
 128             Either.right(JanusGraphOperationStatus.GRAPH_IS_NOT_AVAILABLE));
 129         when(janusGraphGenericDao.getChild(any(), any(), any(), eq(NodeTypeEnum.Resource), eq(ResourceMetadataData.class))).thenReturn(
 130             Either.right(JanusGraphOperationStatus.NOT_FOUND));
 131         when(janusGraphGenericDao.getNode(any(), any(), eq(InterfaceData.class))).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 132         when(janusGraphGenericDao.createNode(any(), eq(InterfaceData.class))).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 133         when(janusGraphGenericDao.createRelation(any(), any(), eq(GraphEdgeLabels.INTERFACE), any())).thenReturn(
 134             Either.right(JanusGraphOperationStatus.OK));
 135         Assert.assertTrue(interfaceLifecycleOperation.createInterfaceOnResource(buildInterfaceDefinition(), "", "", false, false).isRight());
 136         when(janusGraphGenericDao.createRelation(any(), any(), eq(GraphEdgeLabels.INTERFACE), any())).thenReturn(
 137             Either.left(Mockito.mock(GraphRelation.class)));
 138         Assert.assertTrue(interfaceLifecycleOperation.createInterfaceOnResource(buildInterfaceDefinition(), "", "", false, false).isRight());
 139     }
 140
 141     @Test
 142     public void getAllInterfacesOfResourceTest() {
 143         assertTrue(interfaceLifecycleOperation.getAllInterfacesOfResource(null, true).isRight());
 144         when(janusGraphGenericDao.getChildrenNodes(any(), any(), any(), any(), eq(InterfaceData.class))).thenReturn(
 145             Either.right(JanusGraphOperationStatus.GRAPH_IS_NOT_AVAILABLE));
 146         when(janusGraphGenericDao.getChild(any(), any(), any(), eq(NodeTypeEnum.Resource), eq(ResourceMetadataData.class))).thenReturn(
 147             Either.right(JanusGraphOperationStatus.NOT_FOUND));
 148         assertTrue(interfaceLifecycleOperation.getAllInterfacesOfResource("null", true).isLeft());
 149
 150         when(janusGraphGenericDao.getChild(any(), any(), any(), eq(NodeTypeEnum.Resource), eq(ResourceMetadataData.class))).thenReturn(
 151             Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 152         assertTrue(interfaceLifecycleOperation.getAllInterfacesOfResource("null", true).isRight());
 153
 154         ResourceMetadataData key = Mockito.mock(ResourceMetadataData.class);
 155         ComponentMetadataDataDefinition def = Mockito.mock(ComponentMetadataDataDefinition.class);
 156         when(def.getUniqueId()).thenReturn("UNIIIIIIQUE IDDDD");
 157         when(key.getMetadataDataDefinition()).thenReturn(def);
 158         ImmutablePair<ResourceMetadataData, GraphEdge> pair = new ImmutablePair<>(key, Mockito.mock(GraphEdge.class));
 159         when(janusGraphGenericDao.getChild(any(), any(), any(), eq(NodeTypeEnum.Resource), eq(ResourceMetadataData.class)))
 160             .thenReturn(Either.left(pair))
 161             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 162         assertTrue(interfaceLifecycleOperation.getAllInterfacesOfResource("null", true).isLeft());
 163     }
 164
 165     @Test
 166     public void testGetAllInterfaceLifecycleTypes_TypesNotFound() {
 167         when(janusGraphGenericDao.getByCriteriaForModel(NodeTypeEnum.Interface, Collections.emptyMap(), StringUtils.EMPTY,
 168             InterfaceData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 169         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(
 170             StringUtils.EMPTY);
 171         Assert.assertEquals(types.isRight(), Boolean.TRUE);
 172     }
 173
 174     @Test
 175     public void testGetAllInterfaceLifecycleTypes_Success() {
 176         final String UNIQUE_ID = "UNIQUE_ID";
 177         final String TYPE = "UNIQUE_ID";
 178         InterfaceData interfaceData = new InterfaceData();
 179         interfaceData.getInterfaceDataDefinition().setUniqueId(UNIQUE_ID);
 180         interfaceData.getInterfaceDataDefinition().setType(TYPE);
 181         List<InterfaceData> interfaceDataList = new ArrayList<>();
 182         interfaceDataList.add(interfaceData);
 183         Either<List<InterfaceData>, JanusGraphOperationStatus> allInterfaceTypes = Either.left(interfaceDataList);
 184         when(janusGraphGenericDao
 185             .getByCriteriaForModel(NodeTypeEnum.Interface, Collections.emptyMap(), StringUtils.EMPTY, InterfaceData.class)).thenReturn(
 186             allInterfaceTypes);
 187
 188         List<ImmutablePair<OperationData, GraphEdge>> list = new ArrayList<>();
 189         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = Either.left(list);
 190         when(janusGraphGenericDao.getChildrenNodes(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION,
 191             NodeTypeEnum.InterfaceOperation, OperationData.class)).thenReturn(childrenNodes);
 192         when(janusGraphGenericDao.getParentNode(any(), any(), any(), any(), any()))
 193             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 194         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(
 195             StringUtils.EMPTY);
 196         Assert.assertEquals(types.left().value().size(), 1);
 197     }
 198
 199     @Test
 200     public void testGetAllInterfaceLifecycleTypesWithModel() {
 201         final var uid = UniqueIdBuilder.buildInterfaceTypeUid(MODEL_NAME, INTERFACE_TYPE);
 202         final var modelData = new ModelData(MODEL_NAME, uid, ModelTypeEnum.NORMATIVE);
 203         final ImmutablePair<GraphNode, GraphEdge> modelNode = new ImmutablePair<>(modelData, Mockito.mock(GraphEdge.class));
 204
 205         final InterfaceData interfaceData = new InterfaceData();
 206         interfaceData.getInterfaceDataDefinition().setUniqueId(uid);
 207         interfaceData.getInterfaceDataDefinition().setType(INTERFACE_TYPE);
 208
 209         final List<InterfaceData> interfaceTypes = new ArrayList<InterfaceData>();
 210         interfaceTypes.add(interfaceData);
 211
 212         when(janusGraphGenericDao.getParentNode(any(), any(), any(), any(), any()))
 213             .thenReturn(Either.left(modelNode));
 214         when(janusGraphGenericDao
 215             .getByCriteriaForModel(NodeTypeEnum.Interface, Collections.emptyMap(), MODEL_NAME, InterfaceData.class)).thenReturn(
 216             Either.left(interfaceTypes));
 217         when(janusGraphGenericDao.getChildrenNodes(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION,
 218             NodeTypeEnum.InterfaceOperation, OperationData.class)).thenReturn(Either.left(Collections.emptyList()));
 219
 220         Assert.assertEquals(1, interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(MODEL_NAME).left().value().size());
 221     }
 222
 223
 224     @Test
 225     void removeInterfaceTypeFromAdditionalType() {
 226         String modelName = "model";
 227         String interfaceType = "tosca.artifact.interface.PreviouslyExistingType1";
 228         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 229         interfaceDefinition.setModel(modelName);
 230         interfaceDefinition.setType(interfaceType);
 231
 232         interfaceLifecycleOperation.removeInterfaceTypeFromAdditionalType(interfaceDefinition);
 233         verify(modelOperation).removeTypeFromAdditionalType(ElementTypeEnum.INTERFACE_LIFECYCLE_TYPE, modelName, interfaceType);
 234     }
 235 }