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