gerrit.onap Code Review - sdc.git/blob

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