catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.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.components.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.assertThrows;
  24 import static org.junit.jupiter.api.Assertions.assertTrue;
  25 import static org.mockito.ArgumentMatchers.anyMap;
  26 import static org.mockito.ArgumentMatchers.anyString;
  27 import static org.mockito.ArgumentMatchers.eq;
  28 import static org.mockito.Mockito.doNothing;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31
  32 import java.io.ByteArrayInputStream;
  33 import java.io.IOException;
  34 import java.nio.file.Files;
  35 import java.nio.file.Path;
  36 import java.util.Collections;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Optional;
  40 import org.junit.jupiter.api.BeforeEach;
  41 import org.junit.jupiter.api.Test;
  42 import org.mockito.ArgumentCaptor;
  43 import org.mockito.InjectMocks;
  44 import org.mockito.Mock;
  45 import org.mockito.MockitoAnnotations;
  46 import org.openecomp.sdc.be.dao.api.ActionStatus;
  47 import org.openecomp.sdc.be.exception.BusinessException;
  48 import org.openecomp.sdc.be.model.Model;
  49 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
  50 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
  51 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
  52 import org.openecomp.sdc.common.zip.ZipUtils;
  53 import org.openecomp.sdc.common.zip.exception.ZipException;
  54
  55 class ModelBusinessLogicTest {
  56
  57     @InjectMocks
  58     private ModelBusinessLogic modelBusinessLogic;
  59     @Mock
  60     private ModelOperation modelOperation;
  61     @Mock
  62     private DataTypeImportManager dataTypeImportManager;
  63     private Model model;
  64     private final Path modelImportsResourcePath = Path.of("src/test/resources/modelImports");
  65
  66     @BeforeEach
  67     void setup() {
  68         MockitoAnnotations.openMocks(this);
  69         initTestData();
  70     }
  71
  72     private void initTestData() {
  73         model = new Model("ETSI-SDC-MODEL-TEST");
  74     }
  75
  76     @Test
  77     void createModelTest() {
  78         when(modelOperation.createModel(model, false)).thenReturn(model);
  79         final Model result = modelBusinessLogic.createModel(model);
  80         assertThat(result).isNotNull();
  81         assertThat(result.getName()).isEqualTo(model.getName());
  82     }
  83
  84     @Test
  85     void createModelWithDataTypesTest() {
  86         final String dataTypes = "dummyString";
  87         when(modelOperation.createModel(model, false)).thenReturn(model);
  88         final Model result = modelBusinessLogic.createModel(model, dataTypes);
  89         assertThat(result).isNotNull();
  90         assertThat(result.getName()).isEqualTo(model.getName());
  91
  92         verify(dataTypeImportManager).createDataTypes(dataTypes, model.getName());
  93     }
  94
  95     @Test
  96     void createModelFailTest() {
  97         when(modelOperation.createModel(model, false))
  98             .thenThrow(ModelOperationExceptionSupplier.modelAlreadyExists(model.getName()).get());
  99         final BusinessException exception = assertThrows(BusinessException.class, () -> modelBusinessLogic.createModel(model));
 100         assertThat(((OperationException) exception).getActionStatus().name()).isEqualTo(ActionStatus.MODEL_ALREADY_EXISTS.name());
 101         assertThat(((OperationException) exception).getParams()).contains(model.getName());
 102     }
 103
 104     @Test
 105     void createModelImportsSuccessTest() throws IOException, ZipException {
 106         final var modelId = "modelId";
 107         final var resolve = modelImportsResourcePath.resolve("modelWithSubFolderAndEmptyFolder.zip");
 108         final var zipBytes = Files.readAllBytes(resolve);
 109         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(zipBytes);
 110         final Map<String, byte[]> expectedZipMap = ZipUtils.readZip(zipBytes, false);
 111
 112         when(modelOperation.findModelByName(modelId)).thenReturn(Optional.of(new Model(modelId)));
 113         doNothing().when(modelOperation).createModelImports(eq(modelId), anyMap());
 114
 115         modelBusinessLogic.createModelImports(modelId, byteArrayInputStream);
 116
 117         final ArgumentCaptor<Map<String, byte[]>> zipMapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
 118         verify(modelOperation).createModelImports(eq(modelId), zipMapArgumentCaptor.capture());
 119         expectedZipMap.keySet().forEach(key -> assertTrue(zipMapArgumentCaptor.getValue().containsKey(key), "Expecting import " + key));
 120     }
 121
 122     @Test
 123     void createModelImportsTest_invalidModel() {
 124         //given an empty model
 125         final var modelId = "";
 126
 127         final var emptyByteArrayInputStream = new ByteArrayInputStream(new byte[0]);
 128         var actualOperationException = assertThrows(OperationException.class,
 129             () -> modelBusinessLogic.createModelImports(modelId, emptyByteArrayInputStream));
 130
 131         var expectedOperationException = ModelOperationExceptionSupplier.invalidModel(modelId).get();
 132         assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
 133         assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
 134         assertEquals(actualOperationException.getParams()[0], expectedOperationException.getParams()[0]);
 135
 136         //given a null model
 137         actualOperationException = assertThrows(OperationException.class,
 138             () -> modelBusinessLogic.createModelImports(null, emptyByteArrayInputStream));
 139
 140         expectedOperationException = ModelOperationExceptionSupplier.invalidModel(null).get();
 141         assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
 142         assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
 143         assertEquals(actualOperationException.getParams()[0], expectedOperationException.getParams()[0]);
 144     }
 145
 146     @Test
 147     void createModelImportsTest_nullInputStream() {
 148         final var modelId = "modelId";
 149
 150         final OperationException actualOperationException = assertThrows(OperationException.class,
 151             () -> modelBusinessLogic.createModelImports(modelId, null));
 152
 153         final OperationException expectedOperationException = ModelOperationExceptionSupplier.emptyModelImports().get();
 154         assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
 155         assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
 156     }
 157
 158     @Test
 159     void createModelImportsTest_emptyModelImports() throws IOException {
 160         final var modelId = "modelId";
 161
 162         final var resolve = modelImportsResourcePath.resolve("emptyModelImports.zip");
 163         final var zipBytes = Files.readAllBytes(resolve);
 164         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(zipBytes);
 165
 166         when(modelOperation.findModelByName(modelId)).thenReturn(Optional.of(new Model(modelId)));
 167
 168         final OperationException actualOperationException = assertThrows(OperationException.class,
 169             () -> modelBusinessLogic.createModelImports(modelId, byteArrayInputStream));
 170
 171         final OperationException expectedOperationException = ModelOperationExceptionSupplier.emptyModelImports().get();
 172         assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
 173         assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
 174     }
 175
 176     @Test
 177     void createModelImportsTest_modelNotFound() {
 178         final var modelId = "modelId";
 179         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(new byte[0]);
 180
 181         when(modelOperation.findModelByName(modelId)).thenReturn(Optional.empty());
 182
 183         final OperationException actualOperationException = assertThrows(OperationException.class,
 184             () -> modelBusinessLogic.createModelImports(modelId, byteArrayInputStream));
 185
 186         final OperationException expectedOperationException = ModelOperationExceptionSupplier.invalidModel(modelId).get();
 187         assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
 188         assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
 189     }
 190
 191     @Test
 192     void findModelSuccessTest() {
 193         final var modelId = "modelId";
 194         when(modelOperation.findModelByName(modelId)).thenReturn(Optional.of(new Model(modelId)));
 195         final Optional<Model> actualModel = modelBusinessLogic.findModel(modelId);
 196         assertTrue(actualModel.isPresent());
 197         assertEquals(new Model(modelId), actualModel.get());
 198     }
 199
 200     @Test
 201     void findModelTest_emptyOrNullModelName() {
 202         when(modelOperation.findModelByName(anyString())).thenReturn(Optional.of(new Model()));
 203         var actualModel = modelBusinessLogic.findModel("");
 204         assertTrue(actualModel.isEmpty());
 205         actualModel = modelBusinessLogic.findModel(null);
 206         assertTrue(actualModel.isEmpty());
 207     }
 208
 209     @Test
 210     void listModelsSuccessTest() {
 211         final List<Model> expectedModelList = List.of(new Model());
 212         when(modelOperation.findAllModels()).thenReturn(expectedModelList);
 213         final List<Model> actualModelList = modelBusinessLogic.listModels();
 214         assertEquals(expectedModelList, actualModelList, "The model list should be as expected");
 215     }
 216
 217     @Test
 218     void listModelsTest_emptyList() {
 219         when(modelOperation.findAllModels()).thenReturn(Collections.emptyList());
 220         final List<Model> actualModelList = modelBusinessLogic.listModels();
 221         assertTrue(actualModelList.isEmpty(), "The model list should be empty");
 222     }
 223 }