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