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