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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 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
   8  *
   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.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19 package org.openecomp.sdc.be.model.operations.impl;
  20
  21 import static org.assertj.core.api.Assertions.assertThat;
  22 import static org.mockito.Mockito.when;
  23
  24 import fj.data.Either;
  25 import java.util.ArrayList;
  26 import java.util.Collections;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import org.junit.jupiter.api.BeforeEach;
  31 import org.junit.jupiter.api.Test;
  32 import org.mockito.InjectMocks;
  33 import org.mockito.Mock;
  34 import org.mockito.MockitoAnnotations;
  35 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
  36 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  37 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
  38 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  39 import org.openecomp.sdc.be.model.DataTypeDefinition;
  40 import org.openecomp.sdc.be.model.Model;
  41 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  42 import org.openecomp.sdc.be.resources.data.DataTypeData;
  43 import org.springframework.test.context.ContextConfiguration;
  44
  45 @ContextConfiguration("classpath:application-context-test.xml")
  46 class DataTypeOperationTest {
  47
  48     @InjectMocks
  49     private DataTypeOperation dataTypeOperation;
  50     @Mock
  51     private ModelOperation modelOperation;
  52     @Mock
  53     private HealingJanusGraphGenericDao janusGraphGenericDao;
  54     @Mock
  55     private ApplicationDataTypeCache applicationDataTypeCache;
  56
  57     private final String modelName = "ETSI-SDC-MODEL-TEST";
  58     private final List<DataTypeData> dataTypesWithoutModel = new ArrayList<>();
  59     private final List<DataTypeData> dataTypesWithModel = new ArrayList<>();
  60     final Map<String, Map<String, DataTypeDefinition>> dataTypesMappedByModel = new HashMap<>();
  61     final Map<String, DataTypeDefinition> allDataTypesFoundDefinitionMap = new HashMap<>();
  62     private Model model;
  63
  64
  65     @BeforeEach
  66     void beforeEachInit() {
  67         MockitoAnnotations.openMocks(this);
  68         initTestData();
  69     }
  70
  71     @Test
  72     void getAllDataTypeNodesTest() {
  73         when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class))
  74             .thenReturn(Either.left(dataTypesWithoutModel));
  75         when(modelOperation.findAllModels()).thenReturn(Collections.singletonList(model));
  76         when(janusGraphGenericDao.getByCriteriaForModel(NodeTypeEnum.DataType, null, modelName, DataTypeData.class))
  77             .thenReturn(Either.left(dataTypesWithModel));
  78         final var dataTypesFound = dataTypeOperation.getAllDataTypeNodes();
  79         assertThat(dataTypesFound.size()).isEqualTo(4);
  80         assertThat(dataTypesFound.containsAll(dataTypesWithoutModel)).isTrue();
  81         assertThat(dataTypesFound.containsAll(dataTypesWithModel)).isTrue();
  82     }
  83
  84     @Test
  85     void getAllDataTypesWithModelTest() {
  86         when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class))
  87             .thenReturn(Either.left(Collections.emptyList()));
  88         when(modelOperation.findAllModels()).thenReturn(Collections.singletonList(model));
  89         when(janusGraphGenericDao.getByCriteriaForModel(NodeTypeEnum.DataType, null, modelName, DataTypeData.class))
  90             .thenReturn(Either.left(dataTypesWithModel));
  91         final var dataTypesFound = dataTypeOperation.getAllDataTypeNodes();
  92         assertThat(dataTypesFound.size()).isEqualTo(2);
  93         assertThat(dataTypesFound.containsAll(dataTypesWithModel)).isTrue();
  94         assertThat(dataTypesFound.containsAll(dataTypesWithoutModel)).isFalse();
  95     }
  96
  97     @Test
  98     void getAllDataTypeNodesWithValidationErrorTest() {
  99         when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class))
 100             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 101         final var dataTypesFound = dataTypeOperation.getAllDataTypeNodes();
 102         assertThat(dataTypesFound.isEmpty()).isTrue();
 103     }
 104
 105     @Test
 106     void getAllDataTypesWithModelWithValidationErrorTest() {
 107         when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class))
 108             .thenReturn(Either.left(Collections.emptyList()));
 109         when(modelOperation.findAllModels()).thenReturn(Collections.singletonList(model));
 110         when(janusGraphGenericDao.getByCriteriaForModel(NodeTypeEnum.DataType, null, modelName, DataTypeData.class))
 111             .thenReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR));
 112         final var dataTypesFound = dataTypeOperation.getAllDataTypeNodes();
 113         assertThat(dataTypesFound).isEmpty();
 114     }
 115
 116     @Test
 117     void mapDataTypesDefinitionByModelTest() {
 118         final var allDataTypesMappedByModel =
 119             dataTypeOperation.mapDataTypesDefinitionByModel(allDataTypesFoundDefinitionMap);
 120         assertThat(allDataTypesMappedByModel.get(modelName).size()).isEqualTo(2);
 121         assertThat(allDataTypesMappedByModel.get(null)).isNotEmpty();
 122     }
 123
 124
 125     private void initTestData() {
 126         model = new Model(modelName, ModelTypeEnum.NORMATIVE);
 127         final String TEST_DATA_TYPE_001 = "test.data.type001";
 128         final String TEST_DATA_TYPE_002 = "test.data.type002";
 129         final String TEST_DATA_TYPE_003 = "test.data.type003";
 130         final String TEST_DATA_TYPE_004 = "test.data.type004";
 131         final DataTypeData dataTypeData1 = createDataTypeData("test.data.type1", TEST_DATA_TYPE_001, 101L,
 132             101L, null);
 133         final DataTypeData dataTypeData2 = createDataTypeData("test.data.type2", TEST_DATA_TYPE_002, 101L,
 134             1002L, null);
 135         dataTypesWithoutModel.add(dataTypeData1);
 136         dataTypesWithoutModel.add(dataTypeData2);
 137
 138         final DataTypeData dataTypeWithModel1 = createDataTypeData("test.data.type1", TEST_DATA_TYPE_003, 101L,
 139             101L, modelName);
 140         final DataTypeData dataTypeWithModel2 = createDataTypeData("test.data.type2", TEST_DATA_TYPE_004, 101L,
 141             1002L, modelName);
 142         dataTypesWithModel.add(dataTypeWithModel1);
 143         dataTypesWithModel.add(dataTypeWithModel2);
 144
 145         allDataTypesFoundDefinitionMap.put(TEST_DATA_TYPE_001, createDataTypeDefinition("test.data.type1", TEST_DATA_TYPE_001,
 146             101L, 101L, null));
 147         allDataTypesFoundDefinitionMap.put(TEST_DATA_TYPE_002, createDataTypeDefinition("test.data.type2", TEST_DATA_TYPE_002,
 148             101L, 101L, null));
 149         allDataTypesFoundDefinitionMap.put(TEST_DATA_TYPE_003, createDataTypeDefinition("test.data.type1", TEST_DATA_TYPE_003,
 150             101L, 101L, modelName));
 151         allDataTypesFoundDefinitionMap.put(TEST_DATA_TYPE_004, createDataTypeDefinition("test.data.type2", TEST_DATA_TYPE_004,
 152             101L, 101L, modelName));
 153
 154         dataTypesMappedByModel.put(null, allDataTypesFoundDefinitionMap);
 155     }
 156
 157     private DataTypeData createDataTypeData(final String name, final String uniqueId, final long creationTime, final long modificationTime,
 158                                             final String model) {
 159         final DataTypeData dataTypeData = new DataTypeData();
 160         dataTypeData.setDataTypeDataDefinition(createDataTypeDefinition(name, uniqueId, creationTime, modificationTime, model));
 161         return dataTypeData;
 162     }
 163
 164     private DataTypeDefinition createDataTypeDefinition(final String name, final String uniqueId, final long creationTime,
 165                                                         final long modificationTime, String model) {
 166         final DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
 167         dataTypeDefinition.setName(name);
 168         dataTypeDefinition.setUniqueId(uniqueId);
 169         dataTypeDefinition.setCreationTime(creationTime);
 170         dataTypeDefinition.setModificationTime(modificationTime);
 171         dataTypeDefinition.setModel(model);
 172         return dataTypeDefinition;
 173     }
 174
 175 }