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.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
 188     String updatedName = IMAGE1_ID +" name updated";
 189     CompositionEntityValidationData toBeReturned =
 190         new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
 191
 192     toBeReturned.setErrors(Arrays.asList("#/name: "+updatedName+" is not a valid value."+
 193         IMAGE1_ID+"is the only possible value for this field"));
 194     doReturn(toBeReturned).when(compositionEntityDataManagerMock).validateEntity(anyObject(),anyObject(),anyObject());
 195
 196     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 197     Image imageData = new Image();
 198     imageData.setFileName(updatedName);
 199     imageData.setDescription(IMAGE1_ID + " desc updated");
 200     imageEntity.setImageCompositionData(imageData);
 201
 202     CompositionEntityValidationData output = imageManager.updateImage(imageEntity);
 203     Assert.assertEquals(output.getErrors(), toBeReturned.getErrors());
 204
 205   }
 206
 207   @Test
 208   public void testGetNonExistingImageId_negative() {
 209     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id",
 210         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 211   }
 212
 213   @Test
 214   public void testGet() {
 215     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 216     doReturn(expected).when(imageDao).get(anyObject());
 217     String compositionSchema = "schema string";
 218     doReturn(compositionSchema).when(imageManager).getImageCompositionSchema(anyObject());
 219
 220     CompositionEntityResponse<Image> response =
 221         imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 222     Assert.assertEquals(response.getId(), expected.getId());
 223     Assert.assertEquals(response.getData().getFileName(), expected.getImageCompositionData().
 224         getFileName());
 225     Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().
 226         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(anyObject());
 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(anyObject());
 248     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 249     imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 250     verify(imageDao).delete(anyObject());
 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(anyObject());
 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(anyObject(), anyObject());
 274     doReturn(new ImageEntity()).when(imageDao).get(anyObject());
 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(){{
 289             add(imageEntity);
 290         }};
 291
 292         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 293         doReturn(imageEntity).when(imageDao).get(anyObject());
 294         doReturn(imageEntities).when(imageDao).list(anyObject());
 295         doReturn(imageEntities.get(0)).when(imageDao).getQuestionnaireData(anyObject(), anyObject(), anyObject(), anyObject());
 296
 297         imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
 298         Assert.fail();
 299     } catch (CoreException exception) {
 300         Assert.assertEquals(exception.code().id(), VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED);
 301
 302     }
 303   }
 304
 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(anyObject());
 315
 316     doReturn(false).when(vspInfoDao).isManual(anyObject(), anyObject());
 317     doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 318
 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   */
 329
 330   @Test
 331   public void testUpdateHEATImageQuestionnaireWithInvalidFormat() throws Exception {
 332     String json = "{\"format\" :\"qcow2\"}";
 333     ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 334     image.setQuestionnaireData(json);
 335     doReturn(image).when(imageDao).get(anyObject());
 336
 337     String updJson = "{\"format\" :\"a22\"}";
 338     try {
 339       imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
 340       Assert.fail();
 341     } catch (CoreException ex) {
 342       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
 343     }
 344   }
 345
 346   private void testCreate_negative(ImageEntity image, String expectedErrorCode) {
 347     try {
 348       imageManager.createImage(image);
 349       Assert.fail();
 350     } catch (CoreException exception) {
 351       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 352     }
 353   }
 354
 355   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 356                                    String expectedErrorCode) {
 357     try {
 358       imageManager.deleteImage(vspId, version, componentId, nicId);
 359       Assert.fail();
 360     } catch (CoreException exception) {
 361       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 362     }
 363   }
 364
 365   private static ImageEntity createImage(String vspId, Version version, String compId,
 366                                          String imageId) {
 367     ImageEntity imageEntity = new ImageEntity(vspId, version, compId, imageId);
 368     Image imageData = new Image();
 369     imageData.setFileName(imageId + "_name");
 370     imageData.setDescription(imageId + " desc");
 371     imageEntity.setImageCompositionData(imageData);
 372     return imageEntity;
 373   }
 374
 375   private void testUpdate_negative(String vspId, Version version, String componentId,
 376                                    String imageId, String expectedErrorCode) {
 377     try {
 378       imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId));
 379       Assert.fail();
 380     } catch (CoreException exception) {
 381       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 382     }
 383   }
 384
 385   private void testGet_negative(String vspId, Version version, String componentId, String imageId,
 386                                 String expectedErrorCode) {
 387     try {
 388       imageManager.getImage(vspId, version, componentId, imageId);
 389       Assert.fail();
 390     } catch (CoreException exception) {
 391       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 392     }
 393   }
 394
 395 }