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