catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ModelOperationTest.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.junit.jupiter.api.Assertions.assertEquals;
  23 import static org.junit.jupiter.api.Assertions.assertFalse;
  24 import static org.junit.jupiter.api.Assertions.assertNotNull;
  25 import static org.junit.jupiter.api.Assertions.assertThrows;
  26 import static org.junit.jupiter.api.Assertions.assertTrue;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.anyList;
  29 import static org.mockito.ArgumentMatchers.anyMap;
  30 import static org.mockito.ArgumentMatchers.anyString;
  31 import static org.mockito.ArgumentMatchers.eq;
  32 import static org.mockito.Mockito.mock;
  33 import static org.mockito.Mockito.never;
  34 import static org.mockito.Mockito.verify;
  35 import static org.mockito.Mockito.when;
  36 import static org.openecomp.sdc.be.model.operations.impl.ModelOperation.ADDITIONAL_TYPE_DEFINITIONS_PATH;
  37
  38 import fj.data.Either;
  39 import java.io.IOException;
  40 import java.nio.charset.StandardCharsets;
  41 import java.nio.file.Files;
  42 import java.nio.file.Path;
  43 import java.util.ArrayList;
  44 import java.util.Collections;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Optional;
  48 import java.util.TreeMap;
  49 import java.util.stream.Stream;
  50 import org.apache.commons.lang3.tuple.ImmutablePair;
  51 import org.junit.jupiter.api.BeforeAll;
  52 import org.junit.jupiter.api.BeforeEach;
  53 import org.junit.jupiter.api.Test;
  54 import org.mockito.ArgumentCaptor;
  55 import org.mockito.InjectMocks;
  56 import org.mockito.Mock;
  57 import org.mockito.MockitoAnnotations;
  58 import org.openecomp.sdc.be.dao.api.ActionStatus;
  59 import org.openecomp.sdc.be.dao.cassandra.ToscaModelImportCassandraDao;
  60 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  61 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  62 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  63 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  65 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  66 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  67 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  68 import org.openecomp.sdc.be.data.model.ToscaImportByModel;
  69 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  70 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
  71 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  72 import org.openecomp.sdc.be.model.Model;
  73 import org.openecomp.sdc.be.model.ModelTestBase;
  74 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
  75 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
  76 import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
  77 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  78 import org.openecomp.sdc.be.resources.data.ModelData;
  79 import org.springframework.test.context.ContextConfiguration;
  80
  81 @ContextConfiguration("classpath:application-context-test.xml")
  82 class ModelOperationTest extends ModelTestBase {
  83
  84     @InjectMocks
  85     private ModelOperation modelOperation;
  86     @Mock
  87     private JanusGraphGenericDao janusGraphGenericDao;
  88     @Mock
  89     private JanusGraphDao janusGraphDao;
  90     @Mock
  91     private ToscaModelImportCassandraDao toscaModelImportCassandraDao;
  92     @Mock
  93     private DerivedFromOperation derivedFromOperation;
  94
  95     private final String modelName = "ETSI-SDC-MODEL-TEST";
  96
  97     @BeforeAll
  98     static void beforeAllInit() {
  99         init();
 100     }
 101
 102     @BeforeEach
 103     void beforeEachInit() {
 104         MockitoAnnotations.openMocks(this);
 105     }
 106
 107     @Test
 108     void createModelSuccessTest() {
 109         final ModelData modelData = new ModelData(modelName,  UniqueIdBuilder.buildModelUid(modelName), ModelTypeEnum.NORMATIVE);
 110         when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.left(modelData));
 111         final Model createdModel = modelOperation.createModel(new Model(modelName, ModelTypeEnum.NORMATIVE), false);
 112         assertThat(createdModel).isNotNull();
 113         assertThat(createdModel.getName()).isEqualTo(modelName);
 114     }
 115
 116     @Test
 117     void createDerivedModelSuccessTest() {
 118         final String derivedModelName = "derivedModel";
 119         final ModelData modelData = new ModelData(derivedModelName,  UniqueIdBuilder.buildModelUid(derivedModelName), ModelTypeEnum.NORMATIVE);
 120         when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.left(modelData));
 121
 122         final GraphVertex modelVertex = new GraphVertex();
 123         modelVertex.addMetadataProperty(GraphPropertyEnum.NAME, "baseModel");
 124         modelVertex.addMetadataProperty(GraphPropertyEnum.MODEL_TYPE, ModelTypeEnum.NORMATIVE.getValue());
 125         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), anyMap())).thenReturn(Either.left(Collections.singletonList(modelVertex)));
 126         when(janusGraphGenericDao.getChild(eq("uid"), anyString(), eq(GraphEdgeLabels.DERIVED_FROM), eq(NodeTypeEnum.Model), eq(ModelData.class))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 127         when(derivedFromOperation.addDerivedFromRelation("model.derivedModel", "model.baseModel", NodeTypeEnum.Model)).thenReturn(Either.left(new GraphRelation()));
 128
 129         final Model createdModel = modelOperation.createModel(new Model(derivedModelName, modelName, ModelTypeEnum.NORMATIVE), false);
 130         assertThat(createdModel).isNotNull();
 131         assertThat(createdModel.getName()).isEqualTo(derivedModelName);
 132     }
 133
 134     @Test
 135     void createModelFailWithModelAlreadyExistTest() {
 136         when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.right(JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION));
 137         final var model = new Model(modelName, ModelTypeEnum.NORMATIVE);
 138         assertThrows(OperationException.class, () -> modelOperation.createModel(model, false));
 139     }
 140
 141     @Test
 142     void createModelFailTest() {
 143         when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.right(JanusGraphOperationStatus.GRAPH_IS_NOT_AVAILABLE));
 144         final var model = new Model(modelName, ModelTypeEnum.NORMATIVE);
 145         assertThrows(OperationException.class, () -> modelOperation.createModel(model, false));
 146     }
 147
 148     @Test
 149     void createModelImportsSuccessTest() {
 150         var modelId = "modelId";
 151         var contentEntry1 = "contentEntry1";
 152         var pathEntry1 = "entry1";
 153         var contentEntry2 = "contentEntry2";
 154         var pathEntry2 = "entry2/path";
 155         final Map<String, byte[]> zipContent = new TreeMap<>();
 156         zipContent.put(pathEntry1, contentEntry1.getBytes(StandardCharsets.UTF_8));
 157         zipContent.put(pathEntry2, contentEntry2.getBytes(StandardCharsets.UTF_8));
 158
 159         modelOperation.createModelImports(modelId, zipContent);
 160
 161         final var toscaImport1 = new ToscaImportByModel();
 162         toscaImport1.setModelId(modelId);
 163         toscaImport1.setContent(contentEntry1);
 164         toscaImport1.setFullPath(pathEntry1);
 165         final var toscaImport2 = new ToscaImportByModel();
 166         toscaImport2.setModelId(modelId);
 167         toscaImport2.setContent(contentEntry2);
 168         toscaImport2.setFullPath(pathEntry2);
 169         final List<ToscaImportByModel> toscaImportByModelList = List.of(toscaImport1, toscaImport2);
 170
 171         verify(toscaModelImportCassandraDao).replaceImports(modelId, toscaImportByModelList);
 172     }
 173
 174     @Test
 175     void createModelImportsTest_emptyZipContent() {
 176         var modelId = "modelId";
 177         modelOperation.createModelImports(modelId, Collections.emptyMap());
 178         verify(toscaModelImportCassandraDao, never()).replaceImports(eq(modelId), anyList());
 179         modelOperation.createModelImports(modelId, null);
 180         verify(toscaModelImportCassandraDao, never()).replaceImports(eq(null), anyList());
 181     }
 182
 183     @Test
 184     void findModelVertexSuccessTest() {
 185         final ArgumentCaptor<Map<GraphPropertyEnum, Object>> mapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
 186         final GraphVertex expectedVertex = new GraphVertex();
 187         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), mapArgumentCaptor.capture())).thenReturn(Either.left(List.of(expectedVertex)));
 188         var modelName = "modelName";
 189         final Optional<GraphVertex> modelVertexByNameOpt = modelOperation.findModelVertexByName(modelName);
 190         assertTrue(modelVertexByNameOpt.isPresent());
 191         assertEquals(expectedVertex, modelVertexByNameOpt.get());
 192         final Map<GraphPropertyEnum, Object> value = mapArgumentCaptor.getValue();
 193         assertEquals(modelName, value.get(GraphPropertyEnum.NAME));
 194         assertEquals(UniqueIdBuilder.buildModelUid(modelName), value.get(GraphPropertyEnum.UNIQUE_ID));
 195     }
 196
 197     @Test
 198     void findModelVertexTest_modelNotFound() {
 199         final ArgumentCaptor<Map<GraphPropertyEnum, Object>> mapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
 200         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), mapArgumentCaptor.capture()))
 201             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 202         var modelName = "modelName";
 203
 204         final Optional<GraphVertex> modelVertexByNameOpt = modelOperation.findModelVertexByName(modelName);
 205
 206         assertTrue(modelVertexByNameOpt.isEmpty());
 207         final Map<GraphPropertyEnum, Object> value = mapArgumentCaptor.getValue();
 208         assertEquals(modelName, value.get(GraphPropertyEnum.NAME));
 209         assertEquals(UniqueIdBuilder.buildModelUid(modelName), value.get(GraphPropertyEnum.UNIQUE_ID));
 210     }
 211
 212     @Test
 213     void findModelVertexTest_janusGraphError() {
 214         final ArgumentCaptor<Map<GraphPropertyEnum, Object>> mapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
 215         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), mapArgumentCaptor.capture()))
 216             .thenReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR));
 217         var modelName = "modelName";
 218
 219         final var actualException = assertThrows(OperationException.class, () -> modelOperation.findModelVertexByName(modelName));
 220
 221         assertEquals(ActionStatus.GENERAL_ERROR, actualException.getActionStatus());
 222         final Map<GraphPropertyEnum, Object> value = mapArgumentCaptor.getValue();
 223         assertEquals(modelName, value.get(GraphPropertyEnum.NAME));
 224         assertEquals(UniqueIdBuilder.buildModelUid(modelName), value.get(GraphPropertyEnum.UNIQUE_ID));
 225     }
 226
 227     @Test
 228     void findModelVertexTest_emptyOrNullModelName() {
 229         assertTrue(modelOperation.findModelVertexByName("").isEmpty());
 230         assertTrue(modelOperation.findModelVertexByName(null).isEmpty());
 231     }
 232
 233     @Test
 234     void findModelByNameSuccessTest() {
 235         final ArgumentCaptor<Map<GraphPropertyEnum, Object>> mapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
 236         var modelName = "modelName";
 237         final GraphVertex expectedVertex = mock(GraphVertex.class);
 238         when(expectedVertex.getMetadataProperty(GraphPropertyEnum.NAME)).thenReturn(modelName);
 239         when(expectedVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE)).thenReturn(ModelTypeEnum.NORMATIVE.getValue());
 240         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), mapArgumentCaptor.capture())).thenReturn(Either.left(List.of(expectedVertex)));
 241         when(janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Model), UniqueIdBuilder.buildModelUid(modelName),
 242             GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model, ModelData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 243         final Optional<Model> modelByNameOpt = modelOperation.findModelByName(modelName);
 244
 245         final Map<GraphPropertyEnum, Object> value = mapArgumentCaptor.getValue();
 246         assertEquals(modelName, value.get(GraphPropertyEnum.NAME));
 247         assertEquals(UniqueIdBuilder.buildModelUid(modelName), value.get(GraphPropertyEnum.UNIQUE_ID));
 248
 249         final Model expectedModel = new Model(modelName, ModelTypeEnum.NORMATIVE);
 250         assertTrue(modelByNameOpt.isPresent());
 251         assertEquals(expectedModel, modelByNameOpt.get());
 252     }
 253
 254     @Test
 255     void findModelByNameTest_modelNameNotFound() {
 256         final ArgumentCaptor<Map<GraphPropertyEnum, Object>> mapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
 257         var modelName = "modelName";
 258         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), mapArgumentCaptor.capture()))
 259             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 260         final Optional<Model> modelByNameOpt = modelOperation.findModelByName(modelName);
 261         assertTrue(modelByNameOpt.isEmpty());
 262     }
 263
 264     @Test
 265     void findModelByNameTest_emptyOrNullModelName() {
 266         assertTrue(modelOperation.findModelByName("").isEmpty());
 267         assertTrue(modelOperation.findModelByName(null).isEmpty());
 268     }
 269
 270     @Test
 271     void findAllModelsSuccessTest() {
 272         final GraphVertex expectedVertex = mock(GraphVertex.class);
 273         when(expectedVertex.getMetadataProperty(GraphPropertyEnum.NAME)).thenReturn(modelName);
 274         when(expectedVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE)).thenReturn(ModelTypeEnum.NORMATIVE.getValue());
 275         when(janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, Collections.emptyMap())).thenReturn(Either.left(List.of(expectedVertex)));
 276         when(janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Model), UniqueIdBuilder.buildModelUid(modelName),
 277             GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model, ModelData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 278
 279         final List<Model> actualModelList = modelOperation.findAllModels();
 280         assertFalse(actualModelList.isEmpty());
 281         assertEquals(1, actualModelList.size());
 282         assertEquals(modelName, actualModelList.get(0).getName());
 283     }
 284
 285     @Test
 286     void findAllModelsTest_noModelsFound() {
 287         when(janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, Collections.emptyMap())).thenReturn(Either.left(Collections.emptyList()));
 288         final List<Model> actualModelList = modelOperation.findAllModels();
 289         assertTrue(actualModelList.isEmpty());
 290     }
 291
 292     @Test
 293     void findAllModelsTest_janusGraphNotFound() {
 294         when(janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, Collections.emptyMap()))
 295             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 296         final List<Model> actualModelList = modelOperation.findAllModels();
 297         assertTrue(actualModelList.isEmpty());
 298     }
 299
 300     @Test
 301     void findAllModelsTest_janusGraphError() {
 302         when(janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, Collections.emptyMap()))
 303             .thenReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR));
 304         final var actualException = assertThrows(OperationException.class, () -> modelOperation.findAllModels());
 305         final var expectedException = ModelOperationExceptionSupplier.failedToRetrieveModels(JanusGraphOperationStatus.GENERAL_ERROR).get();
 306         assertEquals(expectedException.getMessage(), actualException.getMessage());
 307     }
 308
 309     @Test
 310     void findAllModelImportsTest() {
 311         //given
 312         final var modelName = "modelName";
 313         final var parentModelName = "parentModelName";
 314         final GraphVertex expectedVertex = mock(GraphVertex.class);
 315         when(expectedVertex.getMetadataProperty(GraphPropertyEnum.NAME)).thenReturn(modelName);
 316         when(expectedVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE)).thenReturn(ModelTypeEnum.NORMATIVE_EXTENSION.getValue());
 317         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.MODEL), anyMap())).thenReturn(Either.left(List.of(expectedVertex)));
 318
 319         final var modelData = new ModelData(parentModelName, parentModelName, ModelTypeEnum.NORMATIVE);
 320         final ImmutablePair<ModelData, GraphEdge> modelDataGraphEdgePair = new ImmutablePair<>(modelData, null);
 321
 322         when(janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Model), UniqueIdBuilder.buildModelUid(modelName),
 323             GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model, ModelData.class)).thenReturn(Either.left(modelDataGraphEdgePair));
 324
 325         final ArrayList<ToscaImportByModel> childModelImportList = new ArrayList<>();
 326         childModelImportList.add(createModelImport(modelName, "anyPath1"));
 327         childModelImportList.add(createModelImport(modelName, "anyPath2"));
 328         when(toscaModelImportCassandraDao.findAllByModel(modelName)).thenReturn(new ArrayList<>(childModelImportList));
 329         final ArrayList<ToscaImportByModel> parentModelImportList = new ArrayList<>();
 330         parentModelImportList.add(createModelImport(parentModelName, "anyPath1"));
 331         parentModelImportList.add(createModelImport(parentModelName, "anyPath2"));
 332         when(toscaModelImportCassandraDao.findAllByModel(parentModelName)).thenReturn(parentModelImportList);
 333
 334         //when
 335         final List<ToscaImportByModel> actualModelImportList = modelOperation.findAllModelImports(modelName, true);
 336
 337         //then
 338         assertFalse(actualModelImportList.isEmpty());
 339         assertEquals(childModelImportList.size() + parentModelImportList.size(), actualModelImportList.size());
 340         Stream.concat(childModelImportList.stream(), parentModelImportList.stream())
 341             .forEach(toscaImportByModel -> assertTrue(actualModelImportList.contains(toscaImportByModel)));
 342     }
 343
 344     @Test
 345     void addTypesToDefaultImportsTest_nonExistingAdditionalTypesImport() throws IOException {
 346         var modelName = "model";
 347         final Path testResourcePath = Path.of("src/test/resources/modelOperation");
 348
 349         final var dataTypesPath = testResourcePath.resolve(Path.of("input-data_types.yaml"));
 350         final var dataTypes = Files.readString(dataTypesPath);
 351
 352         final Path import1RelativePath = Path.of("original-import-1.yaml");
 353         final Path import1Path = testResourcePath.resolve(import1RelativePath);
 354         final Path import2RelativePath = Path.of("original-import-2.yaml");
 355         final Path import2Path = testResourcePath.resolve(import2RelativePath);
 356
 357         var toscaImportByModel1 = new ToscaImportByModel();
 358         toscaImportByModel1.setModelId(modelName);
 359         toscaImportByModel1.setFullPath(import1RelativePath.toString());
 360         toscaImportByModel1.setContent(Files.readString(import1Path));
 361
 362         var toscaImportByModel2 = new ToscaImportByModel();
 363         toscaImportByModel2.setModelId(modelName);
 364         toscaImportByModel2.setFullPath(import2RelativePath.toString());
 365         toscaImportByModel2.setContent(Files.readString(import2Path));
 366
 367         final List<ToscaImportByModel> modelImports = new ArrayList<>();
 368         modelImports.add(toscaImportByModel1);
 369         modelImports.add(toscaImportByModel2);
 370         when(toscaModelImportCassandraDao.findAllByModel(modelName)).thenReturn(modelImports);
 371
 372         modelOperation.addTypesToDefaultImports(ElementTypeEnum.DATA_TYPE, dataTypes, modelName);
 373         ArgumentCaptor<List<ToscaImportByModel>> importListArgumentCaptor = ArgumentCaptor.forClass(List.class);
 374         verify(toscaModelImportCassandraDao).saveAll(eq(modelName), importListArgumentCaptor.capture());
 375
 376         final List<ToscaImportByModel> actualImportList = importListArgumentCaptor.getValue();
 377         assertEquals(3, actualImportList.size());
 378         assertTrue(actualImportList.contains(toscaImportByModel1));
 379         assertTrue(actualImportList.contains(toscaImportByModel2));
 380
 381         var expectedAdditionalTypesImport = new ToscaImportByModel();
 382         expectedAdditionalTypesImport.setModelId(modelName);
 383         expectedAdditionalTypesImport.setFullPath(ADDITIONAL_TYPE_DEFINITIONS_PATH.toString());
 384         expectedAdditionalTypesImport.setContent(Files.readString(testResourcePath.resolve(Path.of("expected-additional_types-1.yaml"))));
 385         final ToscaImportByModel actualAdditionalTypesImport =
 386             actualImportList.stream().filter(expectedAdditionalTypesImport::equals).findFirst().orElse(null);
 387         assertNotNull(actualAdditionalTypesImport);
 388         assertEquals(expectedAdditionalTypesImport.getContent(), actualAdditionalTypesImport.getContent());
 389
 390         var expectedImport1 = new ToscaImportByModel();
 391         expectedImport1.setModelId(modelName);
 392         expectedImport1.setFullPath(import1RelativePath.toString());
 393         expectedImport1.setContent(Files.readString(testResourcePath.resolve(Path.of("expected-import-1.yaml"))));
 394         final ToscaImportByModel actualImport1 = actualImportList.stream().filter(expectedImport1::equals).findFirst().orElse(null);
 395         assertNotNull(actualImport1);
 396         assertEquals(expectedImport1.getContent(), actualImport1.getContent());
 397
 398         var expectedImport2 = new ToscaImportByModel();
 399         expectedImport2.setModelId(modelName);
 400         expectedImport2.setFullPath(import2RelativePath.toString());
 401         expectedImport2.setContent(Files.readString(testResourcePath.resolve(Path.of("expected-import-2.yaml"))));
 402         final ToscaImportByModel actualImport2 = actualImportList.stream().filter(expectedImport2::equals).findFirst().orElse(null);
 403         assertNotNull(actualImport2);
 404         assertEquals(expectedImport2.getContent(), actualImport2.getContent());
 405     }
 406
 407     @Test
 408     void addTypesToDefaultImportsTest_existingAdditionalTypesImport() throws IOException {
 409         var modelName = "model";
 410         final Path testResourcePath = Path.of("src/test/resources/modelOperation");
 411
 412         final var dataTypesPath = testResourcePath.resolve(Path.of("input-data_types.yaml"));
 413         final var dataTypes = Files.readString(dataTypesPath);
 414
 415         final Path import1RelativePath = Path.of("original-import-1.yaml");
 416         final Path import1Path = testResourcePath.resolve(import1RelativePath);
 417
 418         var toscaImportByModel1 = new ToscaImportByModel();
 419         toscaImportByModel1.setModelId(modelName);
 420         toscaImportByModel1.setFullPath(import1RelativePath.toString());
 421         toscaImportByModel1.setContent(Files.readString(import1Path));
 422
 423         var originalAdditionalTypesImport = new ToscaImportByModel();
 424         originalAdditionalTypesImport.setModelId(modelName);
 425         originalAdditionalTypesImport.setFullPath(ADDITIONAL_TYPE_DEFINITIONS_PATH.toString());
 426         final Path originalAdditionalTypesImportPath = testResourcePath.resolve(Path.of("original-additional_types-1.yaml"));
 427         originalAdditionalTypesImport.setContent(Files.readString(originalAdditionalTypesImportPath));
 428
 429         final List<ToscaImportByModel> modelImports = new ArrayList<>();
 430         modelImports.add(toscaImportByModel1);
 431         modelImports.add(originalAdditionalTypesImport);
 432         when(toscaModelImportCassandraDao.findAllByModel(modelName)).thenReturn(modelImports);
 433
 434         modelOperation.addTypesToDefaultImports(ElementTypeEnum.DATA_TYPE, dataTypes, modelName);
 435         ArgumentCaptor<List<ToscaImportByModel>> importListArgumentCaptor = ArgumentCaptor.forClass(List.class);
 436         verify(toscaModelImportCassandraDao).saveAll(eq(modelName), importListArgumentCaptor.capture());
 437
 438         final List<ToscaImportByModel> actualImportList = importListArgumentCaptor.getValue();
 439         assertEquals(2, actualImportList.size());
 440         assertTrue(actualImportList.contains(toscaImportByModel1));
 441
 442         var expectedAdditionalTypesImport = new ToscaImportByModel();
 443         expectedAdditionalTypesImport.setModelId(modelName);
 444         expectedAdditionalTypesImport.setFullPath(ADDITIONAL_TYPE_DEFINITIONS_PATH.toString());
 445         expectedAdditionalTypesImport.setContent(Files.readString(testResourcePath.resolve(Path.of("expected-additional_types-2.yaml"))));
 446         final ToscaImportByModel actualAdditionalTypesImport =
 447             actualImportList.stream().filter(expectedAdditionalTypesImport::equals).findFirst().orElse(null);
 448         assertNotNull(actualAdditionalTypesImport);
 449         assertEquals(expectedAdditionalTypesImport.getContent(), actualAdditionalTypesImport.getContent());
 450
 451         var expectedImport1 = new ToscaImportByModel();
 452         expectedImport1.setModelId(modelName);
 453         expectedImport1.setFullPath(import1RelativePath.toString());
 454         expectedImport1.setContent(Files.readString(testResourcePath.resolve(Path.of("expected-import-1.yaml"))));
 455         final ToscaImportByModel actualImport1 = actualImportList.stream().filter(expectedImport1::equals).findFirst().orElse(null);
 456         assertNotNull(actualImport1);
 457         assertEquals(expectedImport1.getContent(), actualImport1.getContent());
 458
 459     }
 460
 461     private ToscaImportByModel createModelImport(final String parentModelName, final String importPath) {
 462         var toscaImportByModel = new ToscaImportByModel();
 463         toscaImportByModel.setModelId(parentModelName);
 464         toscaImportByModel.setFullPath(importPath);
 465         return toscaImportByModel;
 466     }
 467 }