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 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 testCreateManualImageWithDuplicateName() {
 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(expected, USER);
 121       Assert.fail();
 122     }
 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, USER,
 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, USER);
 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, USER);
 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, USER);
 195     }
 196     catch (CoreException ex) {
 197       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
 198     }
 199
 200   }
 201
 202   @Test
 203   public void testGetNonExistingImageId_negative() {
 204     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id", USER,
 205         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 206   }
 207
 208   @Test
 209   public void testGet() {
 210     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 211     doReturn(expected).when(imageDao).get(anyObject());
 212     String compositionSchema = "schema string";
 213     doReturn(compositionSchema).when(imageManager).getImageCompositionSchema(anyObject());
 214
 215     CompositionEntityResponse<Image> response =
 216         imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
 217     Assert.assertEquals(response.getId(), expected.getId());
 218     Assert.assertEquals(response.getData().getFileName(), expected.getImageCompositionData().
 219         getFileName());
 220     Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().
 221         getDescription());
 222     Assert.assertEquals(response.getSchema(), compositionSchema);
 223   }
 224
 225   @Test
 226   public void testDeleteOnNotManualImage() {
 227     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 228     doReturn(expected).when(imageDao).get(anyObject());
 229     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
 230         VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED);
 231   }
 232
 233   @Test
 234   public void testDeleteOnNotExistImage() {
 235     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
 236         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 237   }
 238
 239   @Test
 240   public void testDeleteOnManualImage() {
 241     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 242     doReturn(expected).when(imageDao).get(anyObject());
 243     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 244     imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
 245     verify(imageDao).delete(anyObject());
 246   }
 247
 248   @Test
 249   public void testGetQuestionnaire() throws Exception {
 250     ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 251     image.setQuestionnaireData("{}");
 252     doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 253
 254     String schema = "schema string";
 255     doReturn(schema).when(imageManager).getImageQuestionnaireSchema(anyObject());
 256
 257     QuestionnaireResponse questionnaire =
 258         imageManager.getImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
 259     Assert.assertNotNull(questionnaire);
 260     Assert.assertEquals(questionnaire.getData(), image.getQuestionnaireData());
 261     Assert.assertEquals(questionnaire.getSchema(), schema);
 262     Assert.assertNull(questionnaire.getErrorMessage());
 263   }
 264
 265   @Test
 266   public void testUpdateManualImageQuestionnaire() throws Exception {
 267     String json = "{\"md5\" :\"FFDSD33SS\"}";
 268     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 269     doReturn(new ImageEntity()).when(imageDao).get(anyObject());
 270
 271     imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json, USER);
 272     verify(imageDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
 273   }
 274
 275   @Test
 276   public void testUpdateHEATImageQuestionnaireWithFormat() throws Exception {
 277     String json = "{\"format\" :\"qcow2\"}";
 278     ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 279     image.setQuestionnaireData(json);
 280     doReturn(image).when(imageDao).get(anyObject());
 281
 282     doReturn(false).when(vspInfoDao).isManual(anyObject(), anyObject());
 283     doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 284
 285     String updJson = "{\"format\" :\"aki\"}";
 286     try {
 287       imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson,
 288           USER);
 289       Assert.fail();
 290     }
 291     catch(CoreException ex) {
 292       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
 293     }
 294   }
 295
 296   @Test
 297   public void testUpdateHEATImageQuestionnaireWithInvalidFormat() 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     String updJson = "{\"format\" :\"a22\"}";
 304     try {
 305       imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson,
 306           USER);
 307       Assert.fail();
 308     }
 309     catch(CoreException ex) {
 310       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
 311     }
 312   }
 313
 314   private void testList_negative(String vspId, Version version, String componentId, String user,
 315                                  String expectedErrorCode, String expectedErrorMsg) {
 316     try {
 317       imageManager.listImages(vspId, version, componentId, user);
 318       Assert.fail();
 319     } catch (CoreException exception) {
 320       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 321       Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
 322     }
 323   }
 324
 325   private void testCreate_negative(ImageEntity image, String user, String expectedErrorCode) {
 326     try {
 327       imageManager.createImage(image, user);
 328       Assert.fail();
 329     } catch (CoreException exception) {
 330       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 331     }
 332   }
 333
 334   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 335                                    String user,
 336                                    String expectedErrorCode) {
 337     try {
 338       imageManager.deleteImage(vspId, version, componentId, nicId, user);
 339       Assert.fail();
 340     } catch (CoreException exception) {
 341       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 342     }
 343   }
 344
 345   static ImageEntity createImage(String vspId, Version version, String compId, String imageId) {
 346     ImageEntity imageEntity = new ImageEntity(vspId, version, compId, imageId);
 347     Image imageData = new Image();
 348     imageData.setFileName(imageId + " name");
 349     imageData.setDescription(imageId + " desc");
 350     imageEntity.setImageCompositionData(imageData);
 351     return imageEntity;
 352   }
 353
 354   private void testUpdate_negative(String vspId, Version version, String componentId, String
 355       imageId, String user, String expectedErrorCode) {
 356     try {
 357       imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId), user);
 358       Assert.fail();
 359     } catch (CoreException exception) {
 360       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 361     }
 362   }
 363
 364   private void testGet_negative(String vspId, Version version, String componentId, String imageId,
 365                                 String user, String expectedErrorCode) {
 366     try {
 367       imageManager.getImage(vspId, version, componentId, imageId, user);
 368       Assert.fail();
 369     } catch (CoreException exception) {
 370       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 371     }
 372   }
 373
 374 }