openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImplTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  22
  23
  24 import org.junit.After;
  25 import org.junit.Assert;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.mockito.InjectMocks;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.mockito.Spy;
  32 import org.openecomp.sdc.common.errors.CoreException;
  33 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  35 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  36 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  37 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  39 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  41 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  42 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  43 import org.openecomp.sdc.versioning.dao.types.Version;
  44 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  45
  46 import java.util.ArrayList;
  47 import java.util.Arrays;
  48 import java.util.Collection;
  49 import java.util.List;
  50
  51 import static org.mockito.ArgumentMatchers.any;
  52 import static org.mockito.Mockito.doReturn;
  53 import static org.mockito.Mockito.never;
  54 import static org.mockito.Mockito.verify;
  55
  56 public class ImageManagerImplTest {
  57
  58     private static final String IMAGE_NOT_EXIST_MSG =
  59             "Vendor Software Product Image with Id image1 does not exist for Vendor Software Product with"
  60                     + " id VSP_ID and version 0.1";
  61
  62     private static final String VSP_ID = "VSP_ID";
  63     private static final Version VERSION = new Version(0, 1);
  64     private static final String COMPONENT_ID = "COMPONENT_ID";
  65     private static final String IMAGE1_ID = "image1";
  66     private static final String IMAGE2_ID = "image2";
  67
  68     private static final String IMAGE_QUEST_SCHEMA =
  69             "{\n" + "\"$schema\": \"http://json-schema.org/draft-04/schema#\",\n" + "\"type\": \"object\",\n"
  70                     + "\"properties\": {\n" + "    \"format\": {\n" + "     \"type\": \"string\",\n"
  71                     + "        \"enum\": [\n"
  72                     + "       \"aki\",\"ami\",\"ari\",\"iso\",\"qcow2\",\"raw\", \"vdi\",\"vhd\",\"vmdk\"\n"
  73                     + "        ]\n" + "    },\n" + "    \"version\": {\n" + "        \"type\": \"string\",\n"
  74                     + "        \"minLength\": 1\n" + "    },\n" + "    \"md5\": {\n" + "        \"type\": \"string\",\n"
  75                     + "        \"maxLength\": 32\n" + "    }\n" + "},\n" + "    \"additionalProperties\": false,\n"
  76                     + "    \"required\": [\n" + "     \"version\"\n" + "    ]\n" + "}";
  77
  78     @Mock
  79     private ImageDao imageDao;
  80     @Mock
  81     private CompositionEntityDataManager compositionEntityDataManagerMock;
  82     @Mock
  83     private VendorSoftwareProductInfoDao vspInfoDao;
  84     @InjectMocks
  85     @Spy
  86     private ImageManagerImpl imageManager;
  87
  88     @Before
  89     public void setUp() throws Exception {
  90         MockitoAnnotations.initMocks(this);
  91     }
  92
  93     @After
  94     public void tearDown() {
  95         imageManager = null;
  96     }
  97
  98
  99     @Test
 100     public void testListWhenNone() {
 101         final Collection<ImageEntity> imageEntities = imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
 102         Assert.assertEquals(imageEntities.size(), 0);
 103     }
 104
 105     @Test
 106     public void testList() {
 107
 108         doReturn(Arrays.asList(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID),
 109                 createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE2_ID))).when(imageDao).list(any());
 110
 111
 112         final Collection<ImageEntity> images = imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
 113         Assert.assertEquals(images.size(), 2);
 114         for (ImageEntity image : images) {
 115             Assert.assertEquals(image.getImageCompositionData().getFileName(),
 116                     IMAGE1_ID.equals(image.getId()) ? IMAGE1_ID + "_name" : IMAGE2_ID + "_name");
 117         }
 118     }
 119
 120     @Test
 121     public void testCreateOnNotManualImage_negative() {
 122
 123         testCreate_negative(new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, null),
 124                 VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 125     }
 126
 127     @Test
 128     public void testCreateManualImage() {
 129         ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 130         doReturn(true).when(vspInfoDao).isManual(any(), any());
 131         imageManager.createImage(expected);
 132         verify(compositionEntityDataManagerMock).createImage(expected);
 133         verify(compositionEntityDataManagerMock).createImage(expected);
 134     }
 135
 136     @Test
 137     public void testUpdateNonExistingImageId_negative() {
 138         testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
 139                 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 140     }
 141
 142     @Test
 143     public void testUpdateImage() {
 144         doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(any());
 145
 146         doReturn(new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID))
 147                 .when(compositionEntityDataManagerMock).validateEntity(any(), any(), any());
 148
 149         ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 150         Image imageData = new Image();
 151         imageData.setFileName(IMAGE1_ID + "_name");
 152         imageData.setDescription(IMAGE1_ID + " desc updated");
 153         imageEntity.setImageCompositionData(imageData);
 154
 155         CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
 156         Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 157         verify(imageDao).update(imageEntity);
 158     }
 159
 160     @Test
 161     public void testIllegalImageUpdate() {
 162         doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(any());
 163
 164         doReturn(true).when(vspInfoDao).isManual(any(), any());
 165
 166         CompositionEntityValidationData toBeReturned =
 167                 new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
 168         toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 169         doReturn(toBeReturned).when(compositionEntityDataManagerMock)
 170                               .validateEntity(any(), any(), any());
 171
 172         ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 173         Image imageData = new Image();
 174         imageData.setFileName(IMAGE1_ID + "_name_updated");
 175         imageData.setDescription(IMAGE1_ID + " desc updated");
 176         imageEntity.setImageCompositionData(imageData);
 177
 178         CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
 179         Assert.assertNotNull(validationData);
 180         Assert.assertEquals(validationData.getErrors().size(), 2);
 181
 182         verify(imageDao, never()).update(imageEntity);
 183     }
 184
 185     @Test
 186     public void testUpdateHEATImageFileName() throws Exception {
 187         doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(any());
 188
 189         String updatedName = IMAGE1_ID + " name updated";
 190         CompositionEntityValidationData toBeReturned =
 191                 new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
 192
 193         toBeReturned.setErrors(Arrays.asList("#/name: " + updatedName + " is not a valid value." + IMAGE1_ID
 194                                                      + "is the only possible value for this field"));
 195         doReturn(toBeReturned).when(compositionEntityDataManagerMock)
 196                               .validateEntity(any(), any(), any());
 197
 198         ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 199         Image imageData = new Image();
 200         imageData.setFileName(updatedName);
 201         imageData.setDescription(IMAGE1_ID + " desc updated");
 202         imageEntity.setImageCompositionData(imageData);
 203
 204         CompositionEntityValidationData output = imageManager.updateImage(imageEntity);
 205         Assert.assertEquals(output.getErrors(), toBeReturned.getErrors());
 206
 207     }
 208
 209     @Test
 210     public void testGetNonExistingImageId_negative() {
 211         testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id",
 212                 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 213     }
 214
 215     @Test
 216     public void testGet() {
 217         ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 218         doReturn(expected).when(imageDao).get(any());
 219         String compositionSchema = "schema string";
 220         doReturn(compositionSchema).when(imageManager).getImageCompositionSchema(any());
 221
 222         CompositionEntityResponse<Image> response = imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 223         Assert.assertEquals(response.getId(), expected.getId());
 224         Assert.assertEquals(response.getData().getFileName(), expected.getImageCompositionData()
 225                                                                       .getFileName());
 226         Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().getDescription());
 227         Assert.assertEquals(response.getSchema(), compositionSchema);
 228     }
 229
 230     @Test
 231     public void testDeleteOnNotManualImage() {
 232         ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 233         doReturn(expected).when(imageDao).get(any());
 234         testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
 235                 VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED);
 236     }
 237
 238     @Test
 239     public void testDeleteOnNotExistImage() {
 240         testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
 241                 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 242     }
 243
 244     @Test
 245     public void testDeleteOnManualImage() {
 246         ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 247         doReturn(expected).when(imageDao).get(any());
 248         doReturn(true).when(vspInfoDao).isManual(any(), any());
 249         imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 250         verify(imageDao).delete(any());
 251     }
 252
 253     @Test
 254     public void testGetQuestionnaire() throws Exception {
 255         ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 256         image.setQuestionnaireData("{}");
 257         doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 258
 259         String schema = "schema string";
 260         doReturn(schema).when(imageManager).getImageQuestionnaireSchema(any());
 261
 262         QuestionnaireResponse questionnaire =
 263                 imageManager.getImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 264         Assert.assertNotNull(questionnaire);
 265         Assert.assertEquals(questionnaire.getData(), image.getQuestionnaireData());
 266         Assert.assertEquals(questionnaire.getSchema(), schema);
 267         Assert.assertNull(questionnaire.getErrorMessage());
 268     }
 269
 270     @Test
 271     public void testUpdateManualImageQuestionnaire() throws Exception {
 272         String json = "{\"md5\" :\"FFDSD33SS\"}";
 273         doReturn(true).when(vspInfoDao).isManual(any(), any());
 274         doReturn(new ImageEntity()).when(imageDao).get(any());
 275
 276         imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
 277         verify(imageDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
 278     }
 279
 280
 281     @Test
 282     public void testUpdateManDupImageVerQuestionnaire() throws Exception {
 283         try {
 284             String json = "{\"md5\" :\"FFDSD33SS\", \"version\" :\"1.0\"}";
 285             ImageEntity imageEntity = new ImageEntity();
 286             imageEntity.setId(IMAGE2_ID);
 287             imageEntity.setQuestionnaireData(json);
 288             List<ImageEntity> imageEntities = new ArrayList<ImageEntity>() {{
 289                 add(imageEntity);
 290             }};
 291
 292             doReturn(true).when(vspInfoDao).isManual(any(), any());
 293             doReturn(imageEntity).when(imageDao).get(any());
 294             doReturn(imageEntities).when(imageDao).list(any());
 295             doReturn(imageEntities.get(0)).when(imageDao)
 296                                           .getQuestionnaireData(any(), any(), any(), any());
 297
 298             doReturn(IMAGE_QUEST_SCHEMA).when(imageManager).getImageQuestionnaireSchema(any());
 299
 300             imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
 301             Assert.fail();
 302         } catch (CoreException exception) {
 303             Assert.assertEquals(exception.code().id(),
 304                     VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED);
 305
 306         }
 307     }
 308
 309     @Test
 310     public void testUpdateHEATImageQuestionnaireWithFormat() throws Exception {
 311         String json = "{\"format\" :\"qcow2\"}";
 312         ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 313         image.setQuestionnaireData(json);
 314         doReturn(image).when(imageDao).get(any());
 315
 316         doReturn(false).when(vspInfoDao).isManual(any(), any());
 317         doReturn(IMAGE_QUEST_SCHEMA).when(imageManager).getImageQuestionnaireSchema(any());
 318         doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 319         String updJson = "{\"format\" :\"aki\"}";
 320         try {
 321             imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
 322             Assert.fail();
 323         } catch (CoreException ex) {
 324             Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
 325         }
 326     }
 327
 328     @Test
 329     public void testUpdateImageQuestionnaireWithInvalidFormat() throws Exception {
 330         String json = "{\"format\" :\"qcow2\"}";
 331         ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 332         image.setQuestionnaireData(json);
 333         doReturn(image).when(imageDao).get(any());
 334
 335         String updJson = "{\"format\" :\"a22\"}";
 336         try {
 337             imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
 338             Assert.fail();
 339         } catch (CoreException ex) {
 340             Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
 341         }
 342     }
 343
 344     private void testCreate_negative(ImageEntity image, String expectedErrorCode) {
 345         try {
 346             imageManager.createImage(image);
 347             Assert.fail();
 348         } catch (CoreException exception) {
 349             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 350         }
 351     }
 352
 353     private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 354                                             String expectedErrorCode) {
 355         try {
 356             imageManager.deleteImage(vspId, version, componentId, nicId);
 357             Assert.fail();
 358         } catch (CoreException exception) {
 359             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 360         }
 361     }
 362
 363     private static ImageEntity createImage(String vspId, Version version, String compId, String imageId) {
 364         ImageEntity imageEntity = new ImageEntity(vspId, version, compId, imageId);
 365         Image imageData = new Image();
 366         imageData.setFileName(imageId + "_name");
 367         imageData.setDescription(imageId + " desc");
 368         imageEntity.setImageCompositionData(imageData);
 369         return imageEntity;
 370     }
 371
 372     private void testUpdate_negative(String vspId, Version version, String componentId, String imageId,
 373                                             String expectedErrorCode) {
 374         try {
 375             imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId));
 376             Assert.fail();
 377         } catch (CoreException exception) {
 378             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 379         }
 380     }
 381
 382     private void testGet_negative(String vspId, Version version, String componentId, String imageId,
 383                                          String expectedErrorCode) {
 384         try {
 385             imageManager.getImage(vspId, version, componentId, imageId);
 386             Assert.fail();
 387         } catch (CoreException exception) {
 388             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 389         }
 390     }
 391
 392 }