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

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