gerrit.onap Code Review - sdc.git/blob

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